Merge 1548dc4 into 908ae56

package.json

@@ -79,7 +79,7 @@
     "google-closure-compiler": "^20150920.0.0",
     "http-server": "^0.8.0",
     "istanbul": "^0.3.22",
-    "jasmine": "^2.3.1",
+    "jasmine": "^2.3.2",
     "jasmine-core": "^2.2.0",
     "lodash": "^3.5.0",
     "platform": "^1.3.0",

perf/micro/immediate-scheduler/operators/count-scalar.js

@@ -0,0 +1,18 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  var oldConcatWithImmediateScheduler = RxOld.Observable.just(25, RxOld.Scheduler.immediate).count();
+  var newConcatWithImmediateScheduler = RxNew.Observable.of(25).count();
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old count over scalar with immediate scheduler', function () {
+        oldConcatWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new count over scalar with immediate scheduler', function () {
+        newConcatWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/count.js

@@ -0,0 +1,18 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  var oldConcatWithImmediateScheduler = RxOld.Observable.range(0, 25, RxOld.Scheduler.immediate).count();
+  var newConcatWithImmediateScheduler = RxNew.Observable.range(0, 25).count();
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old count with immediate scheduler', function () {
+        oldConcatWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new count with immediate scheduler', function () {
+        newConcatWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/filter-scalar-false.js

@@ -0,0 +1,25 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function isEven(x) {
+    return x % 2 === 0;
+  }
+
+  function greaterThanTen(x) {
+    return x > 10;
+  }
+  var oldFilterWithImmediateScheduler = RxOld.Observable.just(45, RxOld.Scheduler.immediate).filter(greaterThanTen).filter(isEven);
+  var newFilterWithImmediateScheduler = RxNew.Observable.of(45).filter(greaterThanTen).filter(isEven);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old filter over scalar in the negative with immediate scheduler', function () {
+        oldFilterWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new filter over scalar in the negative with immediate scheduler', function () {
+        newFilterWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/filter-scalar-true.js

@@ -0,0 +1,25 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function isEven(x) {
+    return x % 2 === 0;
+  }
+
+  function greaterThanTen(x) {
+    return x > 10;
+  }
+  var oldFilterWithImmediateScheduler = RxOld.Observable.just(42, RxOld.Scheduler.immediate).filter(greaterThanTen).filter(isEven);
+  var newFilterWithImmediateScheduler = RxNew.Observable.of(42).filter(greaterThanTen).filter(isEven);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old filter over scalar in the affirmative with immediate scheduler', function () {
+        oldFilterWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new filter over scalar in the affirmative with immediate scheduler', function () {
+        newFilterWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/map-scalar.js

@@ -0,0 +1,25 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function square(x) {
+    return x * x;
+  }
+
+  function double(x) {
+    return x + x;
+  }
+  var oldSelectWithImmediateScheduler = RxOld.Observable.just(42).map(square).map(double);
+  var newSelectWithImmediateScheduler = RxNew.Observable.of(42).map(square).map(double);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old map over scalar with immediate scheduler', function () {
+        oldSelectWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new map over scalar with immediate scheduler', function () {
+        newSelectWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/reduce-scalar-noseed.js

@@ -0,0 +1,21 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function add(acc, x) {
+    return x + x;
+  }
+  var oldReduceWithImmediateScheduler = RxOld.Observable.just(25, RxOld.Scheduler.immediate).reduce(add);
+  var newReduceWithImmediateScheduler = RxNew.Observable.of(25).reduce(add);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old reduce with immediate scheduler', function () {
+        oldReduceWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new reduce with immediate scheduler', function () {
+        newReduceWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/reduce-scalar.js

@@ -0,0 +1,21 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function add(acc, x) {
+    return x + x;
+  }
+  var oldReduceWithImmediateScheduler = RxOld.Observable.just(25, RxOld.Scheduler.immediate).reduce(add, 0);
+  var newReduceWithImmediateScheduler = RxNew.Observable.of(25).reduce(add, 0);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old reduce with immediate scheduler', function () {
+        oldReduceWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new reduce with immediate scheduler', function () {
+        newReduceWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

perf/micro/immediate-scheduler/operators/scan-scalar-noseed.js

@@ -0,0 +1,22 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  function add(acc, x) {
+    return x + x;
+  }
+
+  var oldScanScalarWithImmediateScheduler = RxOld.Observable.of(25, RxOld.Scheduler.immediate).scan(add);
+  var newScanScalarWithImmediateScheduler = RxNew.Observable.of(25).scan(add);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+    .add('old scalar observable scan with immediate scheduler with no seed', function () {
+      oldScanScalarWithImmediateScheduler.subscribe(_next, _error, _complete);
+    })
+    .add('new scalar observable scan with immediate scheduler with no seed', function () {
+      newScanScalarWithImmediateScheduler.subscribe(_next, _error, _complete);
+    });
+};

perf/micro/immediate-scheduler/operators/scan-scalar.js

@@ -6,8 +6,8 @@ module.exports = function (suite) {
     return x + x;
   }
 
-  var oldScanScalarWithImmediateScheduler = RxOld.Observable.of(25, RxOld.Scheduler.immediate).scan(add);
-  var newScanScalarWithImmediateScheduler = RxNew.Observable.of(25).scan(add);
+  var oldScanScalarWithImmediateScheduler = RxOld.Observable.of(25, RxOld.Scheduler.immediate).scan(add, 0);
+  var newScanScalarWithImmediateScheduler = RxNew.Observable.of(25).scan(add, 0);
 
   function _next(x) { }
   function _error(e) { }

perf/micro/immediate-scheduler/operators/skip-scalar-0.js

@@ -0,0 +1,18 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  var oldSkipWithImmediateScheduler = RxOld.Observable.just(50, RxOld.Scheduler.immediate).skip(0);
+  var newSkipWithImmediateScheduler = RxNew.Observable.of(50).skip(0);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+    .add('old skip with immediate scheduler', function () {
+      oldSkipWithImmediateScheduler.subscribe(_next, _error, _complete);
+    })
+    .add('new skip with immediate scheduler', function () {
+      newSkipWithImmediateScheduler.subscribe(_next, _error, _complete);
+    });
+};

perf/micro/immediate-scheduler/operators/skip-scalar-outofbounds.js

@@ -0,0 +1,18 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  var oldSkipWithImmediateScheduler = RxOld.Observable.just(50, RxOld.Scheduler.immediate).skip(25);
+  var newSkipWithImmediateScheduler = RxNew.Observable.of(50).skip(25);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+    .add('old skip with immediate scheduler', function () {
+      oldSkipWithImmediateScheduler.subscribe(_next, _error, _complete);
+    })
+    .add('new skip with immediate scheduler', function () {
+      newSkipWithImmediateScheduler.subscribe(_next, _error, _complete);
+    });
+};

perf/micro/immediate-scheduler/operators/take-scalar.js

@@ -0,0 +1,18 @@
+var RxOld = require('rx');
+var RxNew = require('../../../../index');
+
+module.exports = function (suite) {
+  var oldTakeWithImmediateScheduler = RxOld.Observable.just(50, RxOld.Scheduler.immediate).take(5);
+  var newTakeWithImmediateScheduler = RxNew.Observable.of(50).take(5);
+
+  function _next(x) { }
+  function _error(e) { }
+  function _complete() { }
+  return suite
+      .add('old take with immediate scheduler', function () {
+        oldTakeWithImmediateScheduler.subscribe(_next, _error, _complete);
+      })
+      .add('new take with immediate scheduler', function () {
+        newTakeWithImmediateScheduler.subscribe(_next, _error, _complete);
+      });
+};

spec/observables/ScalarObservable-spec.js

@@ -0,0 +1,129 @@
+var Rx = require('../../dist/cjs/Rx');
+var ScalarObservable = require('../../dist/cjs/observables/ScalarObservable');
+var EmptyObservable = require('../../dist/cjs/observables/EmptyObservable');
+var ErrorObservable = require('../../dist/cjs/observables/ErrorObservable');
+var Observable = Rx.Observable;
+
+describe('ScalarObservable', function () {
+  it('should create expose a value property', function () {
+    var s = new ScalarObservable(1);
+    expect(s.value).toBe(1);
+  });
+
+  describe('prototype.map()', function () {
+    it('should map to a new ScalarObservable', function () {
+      var s = new ScalarObservable(1);
+      var r = s.map(function (x) { return x + '!!!'; });
+      expect(r instanceof ScalarObservable).toBe(true);
+      expect(r.value).toBe('1!!!');
+    });
+
+    it('should return an ErrorObservable if map errors', function () {
+      var s = new ScalarObservable(1);
+      var r = s.map(function (x) { throw 'bad!'; });
+      expect(r instanceof ErrorObservable).toBe(true);
+      expect(r.error).toBe('bad!');
+    });
+  });
+
+  describe('prototype.count()', function () {
+    it('should map to a new ScalarObservable of 1', function () {
+      var s = new ScalarObservable(1);
+      var r = s.count();
+      expect(r instanceof ScalarObservable).toBe(true);
+      expect(r.value).toBe(1);
+    });
+
+    it('should map to a new ScalarObservable of 1 if predicate matches', function () {
+      var s = new ScalarObservable(1);
+      var r = s.count(function (x) { return x === 1; });
+      expect(r instanceof ScalarObservable).toBe(true);
+      expect(r.value).toBe(1);
+    });
+
+    it('should map to a new ScalarObservable of 0 if predicate does not match', function () {
+      var s = new ScalarObservable(1);
+      var r = s.count(function (x) { return x === 0; });
+      expect(r instanceof ScalarObservable).toBe(true);
+      expect(r.value).toBe(0);
+    });
+
+    it('should map to a new ErrorObservable if predicate errors', function () {
+      var s = new ScalarObservable(1);
+      var r = s.count(function () { throw 'bad!'; });
+      expect(r instanceof ErrorObservable).toBe(true);
+      expect(r.error).toBe('bad!');
+    });
+  });
+
+  describe('prototype.filter()', function () {
+    it('should return itself if the filter matches its value', function () {
+      var s = new ScalarObservable(1);
+      var r = s.filter(function (x) { return x === 1; });
+      expect(s).toBe(r);
+    });
+
+    it('should return EmptyObservable if filter does not match', function () {
+      var s = new ScalarObservable(1);
+      var r = s.filter(function (x) { return x === 0; });
+      expect(r instanceof EmptyObservable).toBe(true);
+    });
+
+    it('should map to a new ErrorObservable if predicate errors', function () {
+      var s = new ScalarObservable(1);
+      var r = s.filter(function () { throw 'bad!'; });
+      expect(r instanceof ErrorObservable).toBe(true);
+      expect(r.error).toBe('bad!');
+    });
+  });
+
+  describe('prototype.take()', function () {
+    it('should return itself if count > 0', function () {
+      var s = new ScalarObservable(1);
+      var r = s.take(1);
+      expect(s).toBe(r);
+    });
+
+    it('should return EmptyObservable if count === 0', function () {
+      var s = new ScalarObservable(1);
+      var r = s.take(0);
+      expect(r instanceof EmptyObservable).toBe(true);
+    });
+  });
+
+  describe('prototype.skip()', function () {
+    it('should return itself if count === 0', function () {
+      var s = new ScalarObservable(1);
+      var r = s.skip(0);
+      expect(s).toBe(r);
+    });
+
+    it('should return EmptyObservable if count > 0', function () {
+      var s = new ScalarObservable(1);
+      var r = s.skip(1);
+      expect(r instanceof EmptyObservable).toBe(true);
+    });
+  });
+
+  describe('prototype.reduce()', function () {
+    it('should return a ScalarObservable of the result if there is a seed', function () {
+      var s = new ScalarObservable(1);
+      var r = s.reduce(function (a, x) { return a + x; }, 1);
+      expect(r instanceof ScalarObservable).toBe(true);
+      expect(r.value).toBe(2);
+    });
+
+    it('should return itself if there is no seed', function () {
+      var s = new ScalarObservable(1);
+      var r = s.reduce(function (a, x) { return a + x; });
+      expect(r).toBe(s);
+    });
+  });
+});
+
+// If you uncomment this, jasmine breaks? WEIRD
+// describe('reality', function () {
+//   it('should exist in this universe', function () {
+//     expect(true).toBe(true);
+//   });
+// });