Added synchronous methods and tests

Author: John Haley

lib/core.js

@@ -0,0 +1,136 @@
+'use strict';
+
+var asap = require('asap')
+
+module.exports = Promise;
+function Promise(fn) {
+  if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new')
+  if (typeof fn !== 'function') throw new TypeError('not a function')
+  var state = null
+  var value = null
+  var deferreds = []
+  var self = this
+
+  this.then = function(onFulfilled, onRejected) {
+    return new self.constructor(function(resolve, reject) {
+      handle(new Handler(onFulfilled, onRejected, resolve, reject))
+    })
+  }
+
+  this.state = state;
+
+  this.isFulfilled = function () {
+    debugger;
+    return state === true
+  }
+
+  this.isRejected = function () {
+    return state === false
+  }
+
+  this.isPending = function () {
+    return state === null
+  }
+
+  this.value = function () {
+    if (!this.isFulfilled()) {
+      throw new Error('Cannot get a value of an unfulfilled promise.')
+    }
+
+    return value
+  }
+
+  this.reason = function () {
+    if (!this.isRejected()) {
+      throw new Error('Cannot get a rejection reason of a non-rejected promise.')
+    }
+
+    return reason
+  }
+
+  function handle(deferred) {
+    if (state === null) {
+      deferreds.push(deferred)
+      return
+    }
+    asap(function() {
+      var cb = state ? deferred.onFulfilled : deferred.onRejected
+      if (cb === null) {
+        (state ? deferred.resolve : deferred.reject)(value)
+        return
+      }
+      var ret
+      try {
+        ret = cb(value)
+      }
+      catch (e) {
+        deferred.reject(e)
+        return
+      }
+      deferred.resolve(ret)
+    })
+  }
+
+  function resolve(newValue) {
+    try { //Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.')
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then
+        if (typeof then === 'function') {
+          doResolve(then.bind(newValue), resolve, reject)
+          return
+        }
+      }
+      state = true
+      value = newValue
+      finale()
+    } catch (e) { reject(e) }
+  }
+
+  function reject(newValue) {
+    state = false
+    value = newValue
+    finale()
+  }
+
+  function finale() {
+    for (var i = 0, len = deferreds.length; i < len; i++)
+      handle(deferreds[i])
+    deferreds = null
+  }
+
+  doResolve(fn, resolve, reject)
+}
+
+
+function Handler(onFulfilled, onRejected, resolve, reject){
+  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null
+  this.onRejected = typeof onRejected === 'function' ? onRejected : null
+  this.resolve = resolve
+  this.reject = reject
+}
+
+/**
+ * Take a potentially misbehaving resolver function and make sure
+ * onFulfilled and onRejected are only called once.
+ *
+ * Makes no guarantees about asynchrony.
+ */
+function doResolve(fn, onFulfilled, onRejected) {
+  var done = false;
+  try {
+    fn(function (value) {
+      if (done) return
+      done = true
+      onFulfilled(value)
+    }, function (reason) {
+      if (done) return
+      done = true
+      onRejected(reason)
+    })
+  } catch (ex) {
+    if (done) return
+    done = true
+    onRejected(ex)
+  }
+}

test/synchronous-inspection-tests.js

@@ -0,0 +1,154 @@
+var assert = require('better-assert');
+var Promise = require('../');
+
+describe('synchronous-inspection-tests', function () {
+  it('can poll a promise to see if it is resolved', function () {
+    var finished = null;
+    var fulfilledPromise = new Promise(function(resolve, reject) {
+      var interval = setInterval(function() {
+        if (finished !== null) {
+          clearTimeout(interval);
+
+          if (finished) {
+            resolve(true);
+          }
+          else {
+            reject(false);
+          }
+        }
+      }, 10);
+    });
+
+    assert(fulfilledPromise.isPending());
+    assert(!fulfilledPromise.isFulfilled());
+    assert(!fulfilledPromise.isRejected());
+
+    finished = true;
+
+    setTimeout(function () {
+      assert(fulfilledPromise.isFulfilled());
+      assert(!fulfilledPromise.isRejected());
+      assert(fulfilledPromise.value());
+      assert(!fulfilledPromise.isPending());
+    }, 30);
+  });
+
+  it('can poll a promise to see if it is rejected', function () {
+    var finished = null;
+    var fulfilledPromise = new Promise(function(resolve, reject) {
+      var interval = setInterval(function() {
+        if (finished !== null) {
+          clearTimeout(interval);
+
+          if (finished) {
+            resolve(true);
+          }
+          else {
+            reject(false);
+          }
+        }
+      }, 10);
+    });
+
+    assert(fulfilledPromise.isPending());
+    assert(!fulfilledPromise.isFulfilled());
+    assert(!fulfilledPromise.isRejected());
+
+    finished = false;
+
+    setTimeout(function () {
+      assert(!fulfilledPromise.isFulfilled());
+      assert(fulfilledPromise.isRejected());
+      assert(!fulfilledPromise.reason());
+      assert(!fulfilledPromise.isPending());
+    }, 30);
+  });
+
+  it('will throw an error if getting a value of an unfulfilled promise', function () {
+    var finished = null;
+    var fulfilledPromise = new Promise(function(resolve, reject) {
+      var interval = setInterval(function() {
+        if (finished !== null) {
+          clearTimeout(interval);
+
+          if (finished) {
+            resolve(true);
+          }
+          else {
+            reject(false);
+          }
+        }
+      }, 10);
+    });
+
+    assert(fulfilledPromise.isPending());
+    assert(!fulfilledPromise.isFulfilled());
+    assert(!fulfilledPromise.isRejected());
+
+    try {
+      fulfilledPromise.value();
+
+      assert(false);
+    }
+    catch (e) {
+      assert(true);
+    }
+
+    finished = false;
+
+    setTimeout(function () {
+      try {
+        fulfilledPromise.value();
+
+        assert(false);
+      }
+      catch (e) {
+        assert(true);
+      }
+    }, 30);
+  });
+
+  it('will throw an error if getting a reason of a non-rejected promise', function () {
+    var finished = null;
+    var fulfilledPromise = new Promise(function(resolve, reject) {
+      var interval = setInterval(function() {
+        if (finished !== null) {
+          clearTimeout(interval);
+
+          if (finished) {
+            resolve(true);
+          }
+          else {
+            reject(false);
+          }
+        }
+      }, 10);
+    });
+
+    assert(fulfilledPromise.isPending());
+    assert(!fulfilledPromise.isFulfilled());
+    assert(!fulfilledPromise.isRejected());
+
+    try {
+      fulfilledPromise.reason();
+
+      assert(false);
+    }
+    catch (e) {
+      assert(true);
+    }
+
+    finished = true;
+
+    setTimeout(function () {
+      try {
+        fulfilledPromise.reason();
+
+        assert(false);
+      }
+      catch (e) {
+        assert(true);
+      }
+    }, 30);
+  });
+});