feat(bindCallback): rename fromCallback to bindCallback

since fromCallback does not behave in a manner consistent with other fromX methods, it is being renamed to bindCallback as it returns a bound function that returns an observable

closes #876

spec/observables/from-callback-spec.js → spec/observables/bindCallback-spec.js

@@ -2,14 +2,14 @@
 var Rx = require('../../dist/cjs/Rx');
 var Observable = Rx.Observable;
 
-describe('Observable.fromCallback', function () {
+describe('Observable.bindCallback', function () {
   it('should emit one value from a callback', function (done) {
     function callback(datum, cb) {
       cb(datum);
     }
-    var cbToObs = Observable.fromCallback(callback);
+    var boundCallback = Observable.bindCallback(callback);
 
-    cbToObs(42)
+    boundCallback(42)
       .subscribe(function (x) {
         expect(x).toBe(42);
       }, function () {
@@ -22,9 +22,9 @@ describe('Observable.fromCallback', function () {
     function callback(datum, cb) {
       cb(null, datum);
     }
-    var cbToObs = Observable.fromCallback(callback, null, function (err, datum) { return datum; });
+    var boundCallback = Observable.bindCallback(callback, null, function (err, datum) { return datum; });
 
-    cbToObs(42)
+    boundCallback(42)
       .subscribe(function (x) {
         expect(x).toBe(42);
       }, function () {
@@ -37,9 +37,9 @@ describe('Observable.fromCallback', function () {
     function callback(cb) {
       cb(this.value);
     }
-    var cbToObs = Observable.fromCallback(callback, {value: 42});
+    var boundCallback = Observable.bindCallback(callback, {value: 42});
 
-    cbToObs()
+    boundCallback()
       .subscribe(function (x) {
         expect(x).toBe(42);
       }, function () {
@@ -52,9 +52,9 @@ describe('Observable.fromCallback', function () {
     function callback(cb) {
       cb(42);
     }
-    var cbToObs = Observable.fromCallback(callback, null, function (err) { throw new Error('Yikes!'); });
+    var boundCallback = Observable.bindCallback(callback, null, function (err) { throw new Error('Yikes!'); });
 
-    cbToObs()
+    boundCallback()
       .subscribe(function () {
         // Considered a failure if we don't go directly to err handler
         done.fail('should not be called');
@@ -81,7 +81,7 @@ describe('Observable.fromCallback', function () {
         cb(datum);
       });
     }
-    var subscription = Observable.fromCallback(callback)(42)
+    var subscription = Observable.bindCallback(callback)(42)
       .subscribe(nextSpy, throwSpy, completeSpy);
     subscription.unsubscribe();
 

src/Observable.ts

@@ -134,6 +134,7 @@ export class Observable<T> implements CoreOperators<T>  {
   }
 
   // static method stubs
+  static bindCallback: <T>(callbackFunc: Function, ctx?: Object, selector?: Function, scheduler?: Scheduler) => Function;
   static combineLatest: <T>(...observables: Array<Observable<any> |
                                                   Array<Observable<any>> |
                                                   ((...values: Array<any>) => T) |
@@ -152,7 +153,6 @@ export class Observable<T> implements CoreOperators<T>  {
                                removeHandler: (handler: Function) => void,
                                selector?: (...args: Array<any>) => T) => Observable<T>;
   static fromPromise: <T>(promise: Promise<T>, scheduler?: Scheduler) => Observable<T>;
-  static fromCallback: <T>(callbackFunc: Function, ctx?: Object, selector?: Function, scheduler?: Scheduler) => Function;
   static interval: (interval: number, scheduler?: Scheduler) => Observable<number>;
   static merge: <T>(...observables: Array<Observable<any> | Scheduler | number>) => Observable<T>;
   static never: <T>() => Observable<T>;

src/Rx.KitchenSink.ts

@@ -25,15 +25,14 @@ export interface KitchenSinkOperators<T> extends CoreOperators<T> {
 import './add/operator/combineLatest-static';
 import './add/operator/concat-static';
 import './add/operator/merge-static';
-import './add/observable/defer';
+import './add/observable/bindCallback';
 import './add/observable/empty';
 import './add/observable/forkJoin';
 import './add/observable/from';
 import './add/observable/fromArray';
 import './add/observable/fromEvent';
 import './add/observable/fromEventPattern';
 import './add/observable/fromPromise';
-import './add/observable/fromCallback';
 import './add/observable/interval';
 import './add/observable/never';
 import './add/observable/range';

src/Rx.ts

@@ -11,15 +11,14 @@ import {Observable} from './Observable';
 import './add/operator/combineLatest-static';
 import './add/operator/concat-static';
 import './add/operator/merge-static';
-import './add/observable/defer';
+import './observable/bindCallback';
 import './add/observable/empty';
 import './add/observable/forkJoin';
 import './add/observable/from';
 import './add/observable/fromArray';
 import './add/observable/fromEvent';
 import './add/observable/fromEventPattern';
 import './add/observable/fromPromise';
-import './add/observable/fromCallback';
 import './add/observable/interval';
 import './add/observable/never';
 import './add/observable/range';

src/add/observable/bindCallback.ts

@@ -0,0 +1,3 @@
+import {Observable} from '../../Observable';
+import {BoundCallbackObsevable} from '../../observable/bindCallback';
+Observable.bindCallback = BoundCallbackObsevable.create;

src/observable/fromCallback.ts → src/observable/bindCallback.ts

@@ -6,7 +6,7 @@ import {immediate} from '../scheduler/immediate';
 import {tryCatch} from '../util/tryCatch';
 import {errorObject} from '../util/errorObject';
 
-export class CallbackObservable<T> extends Observable<T> {
+export class BoundCallbackObservable<T> extends Observable<T> {
 
   _isScalar: boolean = false;
   value: T | T[];
@@ -16,7 +16,7 @@ export class CallbackObservable<T> extends Observable<T> {
                    selector: Function = undefined,
                    scheduler: Scheduler = immediate): Function {
     return (...args): Observable<T> => {
-      return new CallbackObservable(callbackFunc, ctx, selector, args, scheduler);
+      return new BoundCallbackObservable(callbackFunc, ctx, selector, args, scheduler);
     };
   }