Merge branch 'master' into root

doc/tutorial/applications.md

@@ -75,7 +75,7 @@ state.subscribe((state) => {
 var prevState = {};
 state.subscribe((state) => {
   if (state.count !== prevState.count) {
-    document.querySelector('#count').innerHTML = state.count;  
+    document.querySelector('#count').innerHTML = state.count;
   }
   if (state.inputValue !== prevState.inputValue) {
     document.querySelector('#hello').innerHTML = 'Hello ' + state.inputValue;
@@ -144,7 +144,7 @@ class MyComponent extends ObservableComponent {
     return (
       <div>
         <ul>
-          {this.state.messages.map(message => <li>{message.text}>/li>)}
+          {this.state.messages.map(message => <li>{message.text}</li>)}
         </ul>
       </div>
     );

doc/tutorial/basics.md

@@ -21,7 +21,7 @@ var exists = Rx.Observable.bindCallback(fs.exists);
 exists('file.txt').subscribe(exists => console.log('Does file exist?', exists));
 
 // From a callback (last argument is a callback)
-// fs.exists = (pathA, pathB, cb(err, result))
+// fs.rename = (pathA, pathB, cb(err, result))
 var rename = Rx.Observable.bindNodeCallback(fs.rename);
 rename('file.txt', 'else.txt').subscribe(() => console.log('Renamed!'));
 ```

spec/Observable-spec.ts

@@ -192,6 +192,60 @@ describe('Observable', () => {
       source.subscribe();
     });
 
+    it('should run unsubscription logic when an error is sent synchronously and subscribe is called with no arguments', () => {
+      let unsubscribeCalled = false;
+      const source = new Observable((subscriber: Rx.Subscriber<string>) => {
+        subscriber.error(0);
+        return () => {
+          unsubscribeCalled = true;
+        };
+      });
+
+      try {
+        source.subscribe();
+      } catch (e) {
+        // error'ing to an empty Observer re-throws, so catch and ignore it here.
+      }
+
+      expect(unsubscribeCalled).to.be.true;
+    });
+
+    it('should run unsubscription logic when an error is sent asynchronously and subscribe is called with no arguments', (done: MochaDone) => {
+      let unsubscribeCalled = false;
+      const source = new Observable((subscriber: Rx.Subscriber<string>) => {
+        const id = setInterval(() => {
+          try {
+            subscriber.error(0);
+          } catch (e) {
+            // asynchronously error'ing to an empty Observer re-throws, so catch and ignore it here.
+          }
+        }, 1);
+        return () => {
+          clearInterval(id);
+          unsubscribeCalled = true;
+        };
+      });
+
+      source.subscribe();
+
+      setTimeout(() => {
+        let err;
+        let errHappened = false;
+        try {
+          expect(unsubscribeCalled).to.be.true;
+        } catch (e) {
+          err = e;
+          errHappened = true;
+        } finally {
+          if (!errHappened) {
+            done();
+          } else {
+            done(err);
+          }
+        }
+      }, 100);
+    });
+
     it('should return a Subscription that calls the unsubscribe function returned by the subscriber', () => {
       let unsubscribeCalled = false;
 

spec/operators/cache-spec.ts

@@ -1,6 +1,6 @@
 import * as Rx from '../../dist/cjs/Rx';
 import {expect} from 'chai';
-declare const {hot, cold, time, expectObservable};
+declare const {hot, cold, time, expectObservable, expectSubscriptions};
 
 declare const rxTestScheduler: Rx.TestScheduler;
 

src/observable/dom/AjaxObservable.ts

@@ -361,7 +361,7 @@ export class AjaxSubscriber<T> extends Subscriber<Event> {
 
   unsubscribe() {
     const { done, xhr } = this;
-    if (!done && xhr && xhr.readyState !== 4) {
+    if (!done && xhr && xhr.readyState !== 4 && typeof xhr.abort === 'function') {
       xhr.abort();
     }
     super.unsubscribe();

src/util/toSubscriber.ts

@@ -1,6 +1,6 @@
-import { PartialObserver } from '../Observer';
 import { Subscriber } from '../Subscriber';
 import { $$rxSubscriber } from '../symbol/rxSubscriber';
+import { PartialObserver, empty as emptyObserver } from '../Observer';
 
 export function toSubscriber<T>(
   nextOrObserver?: PartialObserver<T> | ((value: T) => void),
@@ -18,8 +18,8 @@ export function toSubscriber<T>(
   }
 
   if (!nextOrObserver && !error && !complete) {
-    return new Subscriber();
+    return new Subscriber(emptyObserver);
   }
 
   return new Subscriber(nextOrObserver, error, complete);
-}
+}