Browse Source

promise.block() renamed to promise.wait()

promise.wait() now returns the arguments of the "success" event.  If there
was only a single argument, then it is returned.  If there was more than
one, they are returned as an array.  If there was an error, it is thrown.
See documentation.
v0.7.4-release
Ryan 16 years ago
parent
commit
18d0511777
  1. 28
      src/events.js
  2. 46
      test/mjsunit/test-promise-block.js
  3. 84
      test/mjsunit/test-promise-wait.js
  4. 16
      website/api.txt

28
src/events.js

@ -21,16 +21,38 @@ node.EventEmitter.prototype.listeners = function (type) {
};
// node.Promise is defined in src/events.cc
var promise = node.Promise.prototype;
promise.addCallback = function (listener) {
node.Promise.prototype.addCallback = function (listener) {
this.addListener("success", listener);
return this;
};
promise.addErrback = function (listener) {
node.Promise.prototype.addErrback = function (listener) {
this.addListener("error", listener);
return this;
};
node.Promise.prototype.wait = function () {
var ret;
var had_error = false;
this.addCallback(function () {
if (arguments.length == 1) {
ret = arguments[0];
} else if (arguments.length > 1) {
ret = [];
for (var i = 0; i < arguments.length; i++) {
ret.push(arguments[i]);
}
}
})
.addErrback(function (arg) {
had_error = true;
ret = arg;
})
.block();
if (had_error) throw ret;
return ret;
};
})(); // end anonymous namespace

46
test/mjsunit/test-promise-block.js

@ -1,46 +0,0 @@
include("mjsunit.js");
var p1_done = false;
var p1 = new node.Promise();
p1.addCallback(function () {
p1_done = true;
});
var p2_done = false;
var p2 = new node.Promise();
p2.addCallback(function () {
p2_done = true;
setTimeout(function () {
p1.emitSuccess();
}, 100);
});
var p3_done = false;
var p3 = new node.Promise();
p3.addCallback(function () {
p3_done = true;
});
function onLoad () {
p2.emitSuccess();
assertFalse(p1_done);
assertTrue(p2_done);
assertFalse(p3_done);
p1.block()
assertTrue(p1_done);
assertTrue(p2_done);
assertFalse(p3_done);
p3.emitSuccess();
}
function onExit() {
assertTrue(p1_done);
assertTrue(p2_done);
assertTrue(p3_done);
}

84
test/mjsunit/test-promise-wait.js

@ -0,0 +1,84 @@
include("mjsunit.js");
var p1_done = false;
var p1 = new node.Promise();
p1.addCallback(function () {
assertEquals(1, arguments.length);
assertEquals("single arg", arguments[0]);
p1_done = true;
});
var p2_done = false;
var p2 = new node.Promise();
p2.addCallback(function () {
p2_done = true;
setTimeout(function () {
p1.emitSuccess(["single arg"]);
}, 100);
});
var p3_done = false;
var p3 = new node.Promise();
p3.addCallback(function () {
p3_done = true;
});
var p4_done = false;
var p4 = new node.Promise();
p4.addCallback(function () {
assertEquals(3, arguments.length);
assertEquals("a", arguments[0]);
assertEquals("b", arguments[1]);
assertEquals("c", arguments[2]);
p4_done = true;
});
var p5_done = false;
var p5 = new node.Promise();
p5.addCallback(function () {
p5_done = true;
setTimeout(function () {
p4.emitSuccess(["a","b","c"]);
}, 100);
});
function onLoad () {
p2.emitSuccess();
assertFalse(p1_done);
assertTrue(p2_done);
assertFalse(p3_done);
var ret1 = p1.wait()
assertEquals("single arg", ret1);
assertTrue(p1_done);
assertTrue(p2_done);
assertFalse(p3_done);
p3.emitSuccess();
assertFalse(p4_done);
assertFalse(p5_done);
p5.emitSuccess();
assertFalse(p4_done);
assertTrue(p5_done);
var ret4 = p4.wait();
assertArrayEquals(["a","b","c"], ret4);
assertTrue(p4_done);
}
function onExit() {
assertTrue(p1_done);
assertTrue(p2_done);
assertTrue(p3_done);
assertTrue(p4_done);
assertTrue(p5_done);
}

16
website/api.txt

@ -158,10 +158,16 @@ Adds a listener for the +"success"+ event. Returns the same promise object.
+promise.addErrback(listener)+ ::
Adds a listener for the +"error"+ event. Returns the same promise object.
+promise.block()+ ::
+promise.wait()+ ::
Blocks futher execution until the promise emits a success or error event.
Events setup before the call to +promise.block()+ was made may still be
emitted and executed while +promise.block()+ is blocking.
Events setup before the call to +promise.wait()+ was made may still be
emitted and executed while +promise.wait()+ is blocking.
+
If there was a single argument to the +"success"+ event then it is returned.
If there were multiple arguments to +"success"+ then they are returned as an
array.
+
If +"error"+ was emitted instead, +wait()+ throws an error.
=== Standard I/O
@ -409,10 +415,10 @@ node.fs.rename("/tmp/hello", "/tmp/world").addCallback(function () {
});
------------------------------------------------------------------------------
Or use the +promise.block()+ functionality:
Or use the +promise.wait()+ functionality:
------------------------------------------------------------------------------
node.fs.rename("/tmp/hello", "/tmp/world").block();
node.fs.rename("/tmp/hello", "/tmp/world").wait();
node.fs.stat("/tmp/world").addCallback(function (stats) {
puts("stats: " + JSON.stringify(stats));
});

Loading…
Cancel
Save