Starting modern build

Author: mattpodwysocki

src/modular/modern/helpers/isfunction.js

@@ -0,0 +1,16 @@
+'use strict';
+
+module.exports = (function () {
+  var isFn = function (value) {
+    return typeof value === 'function' || false;
+  };
+
+  // fallback for older versions of Chrome and Safari
+  if (isFn(/x/)) {
+    isFn = function(value) {
+      return typeof value === 'function' &&
+        Object.prototype.toString.call(value) === '[object Function]';
+    };
+  }
+  return isFn;
+}());

src/modular/modern/observable.js

@@ -1,76 +1,71 @@
-// TODO: Refactor longStackSupport and hasStacks
-var Rx.config = {
-  longStackSupport = false;
-};
-var hasStacks = false;
+'use strict';
+
+var Observer = require('./observer');
+var isFunction = require('./helpers/isFunction');
+var AnonymousObservable = require('./observable/anonymousobservable');
 
-function Observable(subscribe) {
-  if (Rx.config.longStackSupport && hasStacks) {
-    try {
-      throw new Error();
-    } catch (e) {
-      this.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
-    }
+function Observable() { }
 
-    var self = this;
-    this._subscribe = function (observer) {
-      var oldOnError = observer.onError.bind(observer);
+/**
+ *  Creates an observable sequence from a specified subscribe method implementation.
+ * @param {Function} subscribe Implementation of the resulting observable sequence's subscribe method, returning a function that will be wrapped in a Disposable.
+ * @returns {Observable} The observable sequence with the specified implementation for the Subscribe method.
+ */
+Observable.create = function (subscribe, parent) {
+  return new AnonymousObservable(subscribe, parent);
+};
 
-      observer.onError = function (err) {
-        makeStackTraceLong(err, self);
-        oldOnError(err);
-      };
 
-      return subscribe.call(self, observer);
-    };
-  } else {
-    this._subscribe = subscribe;
-  }
-}
+/**
+* Determines whether the given object is an Observable
+* @param {Any} An object to determine whether it is an Observable
+* @returns {Boolean} true if an Observable, else false.
+*/
+Observable.isObservable = function (o) {
+  return o && isFunction(o.subscribe);
+};
 
-// Class methods
-Observable['amb'] = require('./observable/amb');
-Observable['case'] = require('./observable/case');
-Observable['catch'] = require('./observable/catch');
-Observable['create'] = require('./observable/create');
-Observable['combineLatest'] = require('./observable/combinelatest');
-Observable['concat'] = require('./observable/concat');
-Observable['defer'] = require('./observable/defer');
-Observable['empty'] = require('./observable/empty');
-Observable['for'] = require('./observable/for');
-Observable['forkJoin'] = require('./observable/forkjoin');
-Observable['from'] = require('./observable/from');
-Observable['fromArray'] = require('./observable/fromarray');
-Observable['fromCallback'] = require('./observable/fromcallback');
-Observable['fromEvent'] = require('./observable/fromevent');
-Observable['fromEventPattern'] = require('./observable/fromeventpattern');
-Observable['fromNodeCallback'] = require('./observable/fromnodecallback');
-Observable['fromPromise'] = require('./observable/frompromise');
-Observable['generate'] = require('./observable/generate');
-Observable['generateWithAbsoluteTime'] = require('./observable/generatewithabsolutetime');
-Observable['generateWithRelativeTime'] = require('./observable/generatewithrelativetime');
-Observable['if'] = require('./observable/if');
-Observable['interval'] = require('./observable/interval');
-Observable['just'] = require('./observable/just');
-Observable['merge'] = require('./observable/merge');
-Observable['never'] = require('./observable/never');
-Observable['of'] = require('./observable/of');
-Observable['ofArrayChanges'] = require('./observable/ofarraychanges');
-Observable['ofObjectChanges'] = require('./observable/ofobjectchanges');
-Observable['onErrorResumeNext'] = require('./observable/onerrorresumenext');
-Observable['pairs'] = require('./observable/pairs');
-Observable['range'] = require('./observable/range');
-Observable['repeat'] = require('./observable/repeat');
-Observable['spawn'] = require('./observable/spawn');
-Observable['throw'] = require('./observable/throw');
-Observable['timer'] = require('./observable/timer');
-Observable['toAsync'] = require('./observable/toasync');
-Observable['using'] = require('./observable/using');
-Observable['when'] = require('./observable/when');
-Observable['zip'] = require('./observable/zip');
+/**
+ *  Subscribes an o to the observable sequence.
+ *  @param {Mixed} [oOrOnNext] The object that is to receive notifications or an action to invoke for each element in the observable sequence.
+ *  @param {Function} [onError] Action to invoke upon exceptional termination of the observable sequence.
+ *  @param {Function} [onCompleted] Action to invoke upon graceful termination of the observable sequence.
+ *  @returns {Diposable} A disposable handling the subscriptions and unsubscriptions.
+ */
+Observable.prototype.subscribe = function (oOrOnNext, onError, onCompleted) {
+  return this._subscribe(typeof oOrOnNext === 'object' ?
+    oOrOnNext :
+    Observer.create(oOrOnNext, onError, onCompleted));
+};
 
-// Instance methods
+/**
+ * Subscribes to the next value in the sequence with an optional "this" argument.
+ * @param {Function} onNext The function to invoke on each element in the observable sequence.
+ * @param {Any} [thisArg] Object to use as this when executing callback.
+ * @returns {Disposable} A disposable handling the subscriptions and unsubscriptions.
+ */
+Observable.prototype.subscribeOnNext = function (onNext, thisArg) {
+  return this._subscribe(Observer.create(typeof thisArg !== 'undefined' ? function(x) { onNext.call(thisArg, x); } : onNext));
+};
 
+/**
+ * Subscribes to an exceptional condition in the sequence with an optional "this" argument.
+ * @param {Function} onError The function to invoke upon exceptional termination of the observable sequence.
+ * @param {Any} [thisArg] Object to use as this when executing callback.
+ * @returns {Disposable} A disposable handling the subscriptions and unsubscriptions.
+ */
+Observable.prototype.subscribeOnError = function (onError, thisArg) {
+  return this._subscribe(Observer.create(null, typeof thisArg !== 'undefined' ? function(e) { onError.call(thisArg, e); } : onError));
+};
 
+/**
+ * Subscribes to the next value in the sequence with an optional "this" argument.
+ * @param {Function} onCompleted The function to invoke upon graceful termination of the observable sequence.
+ * @param {Any} [thisArg] Object to use as this when executing callback.
+ * @returns {Disposable} A disposable handling the subscriptions and unsubscriptions.
+ */
+Observable.prototype.subscribeOnCompleted = function (onCompleted, thisArg) {
+  return this._subscribe(Observer.create(null, null, typeof thisArg !== 'undefined' ? function() { onCompleted.call(thisArg); } : onCompleted));
+};
 
 module.exports = Observable;

src/modular/modern/observable/amb.js

@@ -0,0 +1,46 @@
+' use strict';
+
+var inherits = require('util').inherits;
+var isFunction = require('../helpers/isfunction');
+var Disposable = require('../disposable');
+var tryCatchUtils = require('../helpers/trycatch');
+var Observable = require('../observable');
+var AutoDetachObserver = require('../observer/autodetachobserver');
+
+if (!globals.Rx.Scheduler.currentThread) {
+  require('../scheduler/currentthread');
+}
+
+inherits(AnonymousObservable, Observable);
+
+// Fix subscriber to check for undefined or function returned to decorate as Disposable
+function fixSubscriber(subscriber) {
+  return subscriber && isFunction(subscriber.dispose) ? subscriber :
+    isFunction(subscriber) ? Disposable.create(subscriber) : Disposable.empty;
+}
+
+function setDisposable(s, state) {
+  var ado = state[0], self = state[1];
+  var sub = tryCatchUtils.tryCatch(self.__subscribe).call(self, ado);
+  if (sub === tryCatchUtils.errorObj && !ado.fail(sub.e)) { tryCatchUtils.thrower(sub.e); }
+  ado.setDisposable(fixSubscriber(sub));
+}
+
+function AnonymousObservable(subscribe, parent) {
+  this.source = parent;
+  this.__subscribe = subscribe;
+  Observable.call(this);
+}
+
+AnonymousObservable.prototype._subscribe = function (o) {
+  var ado = new AutoDetachObserver(o), state = [ado, this];
+
+  if (Rx.Scheduler.currentThread.scheduleRequired()) {
+    Rx.Scheduler.currentThread.schedule(state, setDisposable);
+  } else {
+    setDisposable(null, state);
+  }
+  return ado;
+};
+
+module.exports = AnonymousObservable;