rxjs-rails 0.0.1

data/vendor/assets/javascripts/rx.async.js

@@ -0,0 +1,306 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+;(function (factory) {
+    var objectTypes = {
+        'boolean': false,
+        'function': true,
+        'object': true,
+        'number': false,
+        'string': false,
+        'undefined': false
+    };
+
+    var root = (objectTypes[typeof window] && window) || this,
+        freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports,
+        freeModule = objectTypes[typeof module] && module && !module.nodeType && module,
+        moduleExports = freeModule && freeModule.exports === freeExports && freeExports,
+        freeGlobal = objectTypes[typeof global] && global;
+    
+    if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) {
+        root = freeGlobal;
+    }
+
+    // Because of build optimizers
+    if (typeof define === 'function' && define.amd) {
+        define(['rx', 'exports'], function (Rx, exports) {
+            root.Rx = factory(root, exports, Rx);
+            return root.Rx;
+        });
+    } else if (typeof module === 'object' && module && module.exports === freeExports) {
+        module.exports = factory(root, module.exports, require('./rx'));
+    } else {
+        root.Rx = factory(root, {}, root.Rx);
+    }
+}.call(this, function (root, exp, Rx, undefined) {
+    
+    // Aliases
+    var Observable = Rx.Observable,
+        AnonymousObservable = Rx.Internals.AnonymousObservable,
+        AsyncSubject = Rx.AsyncSubject,
+        disposableCreate = Rx.Disposable.create,
+        CompositeDisposable= Rx.CompositeDisposable,
+        AsyncSubject = Rx.AsyncSubject
+        timeoutScheduler = Rx.Scheduler.timeout,
+        slice = Array.prototype.slice;
+
+    /**
+     * Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence.
+     * 
+     * @example
+     * var res = Rx.Observable.start(function () { console.log('hello'); });
+     * var res = Rx.Observable.start(function () { console.log('hello'); }, Rx.Scheduler.timeout);
+     * var res = Rx.Observable.start(function () { this.log('hello'); }, Rx.Scheduler.timeout, console);
+     * 
+     * @param {Function} func Function to run asynchronously.
+     * @param {Scheduler} [scheduler]  Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param [context]  The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Observable} An observable sequence exposing the function's result value, or an exception.
+     * 
+     * Remarks
+     * * The function is called immediately, not during the subscription of the resulting sequence.
+     * * Multiple subscriptions to the resulting sequence can observe the function's result.  
+     */
+    Observable.start = function (func, scheduler, context) {
+        return observableToAsync(func, scheduler, context)();
+    };
+
+    /**
+     * Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler.
+     * 
+     * @example
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; })(4, 3);
+     * var res = Rx.Observable.toAsync(function (x, y) { return x + y; }, Rx.Scheduler.timeout)(4, 3);
+     * var res = Rx.Observable.toAsync(function (x) { this.log(x); }, Rx.Scheduler.timeout, console)('hello');
+     * 
+     * @param {Function} function Function to convert to an asynchronous function.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @returns {Function} Asynchronous function.
+     */
+    var observableToAsync = Observable.toAsync = function (func, scheduler, context) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = arguments, 
+                subject = new AsyncSubject();
+
+            scheduler.schedule(function () {
+                var result;
+                try {
+                    result = func.apply(context, args);
+                } catch (e) {
+                    subject.onError(e);
+                    return;
+                }
+                subject.onNext(result);
+                subject.onCompleted();
+            });
+            return subject.asObservable();
+        };
+    };
+
+    /**
+     * Converts a callback function to an observable sequence. 
+     * 
+     * @param {Function} function Function with a callback as the last parameter to convert to an Observable sequence.
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback to produce a single item to yield on next.
+     * @returns {Function} A function, when executed with the required parameters minus the callback, produces an Observable sequence with a single value of the arguments to the callback as an array.
+     */
+    Observable.fromCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = slice.call(arguments, 0), 
+                subject = new AsyncSubject();
+
+            scheduler.schedule(function () {
+                function handler(e) {
+                    var results = e;
+                    
+                    if (selector) {
+                        try {
+                            results = selector(arguments);
+                        } catch (err) {
+                            subject.onError(err);
+                            return;
+                        }
+                    } else {
+                        if (results.length === 1) {
+                            results = results[0];
+                        }
+                    }
+
+                    subject.onNext(results);
+                    subject.onCompleted();
+                }
+
+                args.push(handler);
+                func.apply(context, args);
+            });
+
+            return subject.asObservable();
+        };
+    };
+
+    /**
+     * Converts a Node.js callback style function to an observable sequence.  This must be in function (err, ...) format.
+     * @param {Function} func The function to call
+     * @param {Scheduler} [scheduler] Scheduler to run the function on. If not specified, defaults to Scheduler.timeout.
+     * @param {Mixed} [context] The context for the func parameter to be executed.  If not specified, defaults to undefined.
+     * @param {Function} [selector] A selector which takes the arguments from the callback minus the error to produce a single item to yield on next.     
+     * @returns {Function} An async function which when applied, returns an observable sequence with the callback arguments as an array.
+     */
+    Observable.fromNodeCallback = function (func, scheduler, context, selector) {
+        scheduler || (scheduler = timeoutScheduler);
+        return function () {
+            var args = slice.call(arguments, 0), 
+                subject = new AsyncSubject();
+
+            scheduler.schedule(function () {
+                function handler(err) {
+                    if (err) {
+                        subject.onError(err);
+                        return;
+                    }
+
+                    var results = slice.call(arguments, 1);
+                    
+                    if (selector) {
+                        try {
+                            results = selector(results);
+                        } catch (e) {
+                            subject.onError(e);
+                            return;
+                        }
+                    } else {
+                        if (results.length === 1) {
+                            results = results[0];
+                        }
+                    }
+
+                    subject.onNext(results);
+                    subject.onCompleted();
+                }
+
+                args.push(handler);
+                func.apply(context, args);
+            });
+
+            return subject.asObservable();
+        };
+    };
+
+    function createListener (element, name, handler) {
+        // Node.js specific
+        if (element.addListener) {
+            element.addListener(name, handler);
+            return disposableCreate(function () {
+                element.removeListener(name, handler);
+            });
+        } else if (element.addEventListener) {
+            element.addEventListener(name, handler, false);
+            return disposableCreate(function () {
+                element.removeEventListener(name, handler, false);
+            });
+        }
+    }
+
+    function createEventListener (el, eventName, handler) {
+        var disposables = new CompositeDisposable();
+
+        // Asume NodeList
+        if (el && el.length) {
+            for (var i = 0, len = el.length; i < len; i++) {
+                disposables.add(createEventListener(el[i], eventName, handler));
+            }
+        } else if (el) {
+            disposables.add(createListener(el, eventName, handler));
+        }
+
+        return disposables;
+    }
+
+    /**
+     * Creates an observable sequence by adding an event listener to the matching DOMElement or each item in the NodeList.
+     *
+     * @example
+     *   var source = Rx.Observable.fromEvent(element, 'mouseup');
+     * 
+     * @param {Object} element The DOMElement or NodeList to attach a listener.
+     * @param {String} eventName The event name to attach the observable sequence.
+     * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.     
+     * @returns {Observable} An observable sequence of events from the specified element and the specified event.
+     */
+    Observable.fromEvent = function (element, eventName, selector) {
+        return new AnonymousObservable(function (observer) {
+            return createEventListener(
+                element, 
+                eventName, 
+                function handler (e) { 
+                    var results = e;
+
+                    if (selector) {
+                        try {
+                            results = selector(arguments);
+                        } catch (err) {
+                            observer.onError(err);
+                            return
+                        }
+                    }
+
+                    observer.onNext(results); 
+                });
+        }).publish().refCount();
+    };
+    /**
+     * Creates an observable sequence from an event emitter via an addHandler/removeHandler pair.
+     * @param {Function} addHandler The function to add a handler to the emitter.
+     * @param {Function} [removeHandler] The optional function to remove a handler from an emitter.
+     * @param {Function} [selector] A selector which takes the arguments from the event handler to produce a single item to yield on next.
+     * @returns {Observable} An observable sequence which wraps an event from an event emitter
+     */
+    Observable.fromEventPattern = function (addHandler, removeHandler, selector) {
+        return new AnonymousObservable(function (observer) {
+            function innerHandler (e) {
+                var result = e;
+                if (selector) {
+                    try {
+                        result = selector(arguments);
+                    } catch (err) {
+                        observer.onError(err);
+                        return;
+                    }
+                }
+                observer.onNext(result);
+            }
+
+            var returnValue = addHandler(innerHandler);
+            return disposableCreate(function () {
+                if (removeHandler) {
+                    removeHandler(innerHandler, returnValue);
+                }
+            });
+        }).publish().refCount();
+    };
+
+    /**
+     * Converts a Promise to an Observable sequence
+     * @param {Promise} A Promises A+ implementation instance.
+     * @returns {Observable} An Observable sequence which wraps the existing promise success and failure.
+     */
+    Observable.fromPromise = function (promise) {
+        var subject = new AsyncSubject();
+        
+        promise.then(
+            function (value) {
+                subject.onNext(value);
+                subject.onCompleted();
+            }, 
+            function (reason) {
+               subject.onError(reason);
+            });
+            
+        return subject.asObservable();
+    };
+    return Rx;
+}));

data/vendor/assets/javascripts/rx.async.min.js

@@ -0,0 +1 @@
+(function(a){var b={"boolean":!1,"function":!0,object:!0,number:!1,string:!1,undefined:!1},c=b[typeof window]&&window||this,d=b[typeof exports]&&exports&&!exports.nodeType&&exports,e=b[typeof module]&&module&&!module.nodeType&&module,f=(e&&e.exports===d&&d,b[typeof global]&&global);!f||f.global!==f&&f.window!==f||(c=f),"function"==typeof define&&define.amd?define(["rx","exports"],function(b,d){return c.Rx=a(c,d,b),c.Rx}):"object"==typeof module&&module&&module.exports===d?module.exports=a(c,module.exports,require("./rx")):c.Rx=a(c,{},c.Rx)}).call(this,function(a,b,c){function d(a,b,c){return a.addListener?(a.addListener(b,c),i(function(){a.removeListener(b,c)})):a.addEventListener?(a.addEventListener(b,c,!1),i(function(){a.removeEventListener(b,c,!1)})):void 0}function e(a,b,c){var f=new j;if(a&&a.length)for(var g=0,h=a.length;h>g;g++)f.add(e(a[g],b,c));else a&&f.add(d(a,b,c));return f}var f=c.Observable,g=c.Internals.AnonymousObservable,h=c.AsyncSubject,i=c.Disposable.create,j=c.CompositeDisposable,h=c.AsyncSubject;timeoutScheduler=c.Scheduler.timeout,slice=Array.prototype.slice,f.start=function(a,b,c){return k(a,b,c)()};var k=f.toAsync=function(a,b,c){return b||(b=timeoutScheduler),function(){var d=arguments,e=new h;return b.schedule(function(){var b;try{b=a.apply(c,d)}catch(f){return e.onError(f),void 0}e.onNext(b),e.onCompleted()}),e.asObservable()}};return f.fromCallback=function(a,b,c,d){return b||(b=timeoutScheduler),function(){var e=slice.call(arguments,0),f=new h;return b.schedule(function(){function b(a){var b=a;if(d)try{b=d(arguments)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)}),f.asObservable()}},f.fromNodeCallback=function(a,b,c,d){return b||(b=timeoutScheduler),function(){var e=slice.call(arguments,0),f=new h;return b.schedule(function(){function b(a){if(a)return f.onError(a),void 0;var b=slice.call(arguments,1);if(d)try{b=d(b)}catch(c){return f.onError(c),void 0}else 1===b.length&&(b=b[0]);f.onNext(b),f.onCompleted()}e.push(b),a.apply(c,e)}),f.asObservable()}},f.fromEvent=function(a,b,c){return new g(function(d){return e(a,b,function(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)})}).publish().refCount()},f.fromEventPattern=function(a,b,c){return new g(function(d){function e(a){var b=a;if(c)try{b=c(arguments)}catch(e){return d.onError(e),void 0}d.onNext(b)}var f=a(e);return i(function(){b&&b(e,f)})}).publish().refCount()},f.fromPromise=function(a){var b=new h;return a.then(function(a){b.onNext(a),b.onCompleted()},function(a){b.onError(a)}),b.asObservable()},c});