2 module.exports = function(Promise, Context) {
3 var getDomain = Promise._getDomain;
4 var async = Promise._async;
5 var Warning = require("./errors").Warning;
6 var util = require("./util");
7 var canAttachTrace = util.canAttachTrace;
8 var unhandledRejectionHandled;
9 var possiblyUnhandledRejection;
10 var bluebirdFramePattern =
11 /[\\\/]bluebird[\\\/]js[\\\/](release|debug|instrumented)/;
12 var stackFramePattern = null;
13 var formatStack = null;
14 var indentStackFrames = false;
16 var debugging = !!(util.env("BLUEBIRD_DEBUG") != 0 &&
18 util.env("BLUEBIRD_DEBUG") ||
19 util.env("NODE_ENV") === "development"));
21 var warnings = !!(util.env("BLUEBIRD_WARNINGS") != 0 &&
22 (debugging || util.env("BLUEBIRD_WARNINGS")));
24 var longStackTraces = !!(util.env("BLUEBIRD_LONG_STACK_TRACES") != 0 &&
25 (debugging || util.env("BLUEBIRD_LONG_STACK_TRACES")));
27 var wForgottenReturn = util.env("BLUEBIRD_W_FORGOTTEN_RETURN") != 0 &&
28 (warnings || !!util.env("BLUEBIRD_W_FORGOTTEN_RETURN"));
30 Promise.prototype.suppressUnhandledRejections = function() {
31 var target = this._target();
32 target._bitField = ((target._bitField & (~1048576)) |
36 Promise.prototype._ensurePossibleRejectionHandled = function () {
37 if ((this._bitField & 524288) !== 0) return;
38 this._setRejectionIsUnhandled();
39 async.invokeLater(this._notifyUnhandledRejection, this, undefined);
42 Promise.prototype._notifyUnhandledRejectionIsHandled = function () {
43 fireRejectionEvent("rejectionHandled",
44 unhandledRejectionHandled, undefined, this);
47 Promise.prototype._setReturnedNonUndefined = function() {
48 this._bitField = this._bitField | 268435456;
51 Promise.prototype._returnedNonUndefined = function() {
52 return (this._bitField & 268435456) !== 0;
55 Promise.prototype._notifyUnhandledRejection = function () {
56 if (this._isRejectionUnhandled()) {
57 var reason = this._settledValue();
58 this._setUnhandledRejectionIsNotified();
59 fireRejectionEvent("unhandledRejection",
60 possiblyUnhandledRejection, reason, this);
64 Promise.prototype._setUnhandledRejectionIsNotified = function () {
65 this._bitField = this._bitField | 262144;
68 Promise.prototype._unsetUnhandledRejectionIsNotified = function () {
69 this._bitField = this._bitField & (~262144);
72 Promise.prototype._isUnhandledRejectionNotified = function () {
73 return (this._bitField & 262144) > 0;
76 Promise.prototype._setRejectionIsUnhandled = function () {
77 this._bitField = this._bitField | 1048576;
80 Promise.prototype._unsetRejectionIsUnhandled = function () {
81 this._bitField = this._bitField & (~1048576);
82 if (this._isUnhandledRejectionNotified()) {
83 this._unsetUnhandledRejectionIsNotified();
84 this._notifyUnhandledRejectionIsHandled();
88 Promise.prototype._isRejectionUnhandled = function () {
89 return (this._bitField & 1048576) > 0;
92 Promise.prototype._warn = function(message, shouldUseOwnTrace, promise) {
93 return warn(message, shouldUseOwnTrace, promise || this);
96 Promise.onPossiblyUnhandledRejection = function (fn) {
97 var domain = getDomain();
98 possiblyUnhandledRejection =
99 typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
103 Promise.onUnhandledRejectionHandled = function (fn) {
104 var domain = getDomain();
105 unhandledRejectionHandled =
106 typeof fn === "function" ? (domain === null ? fn : domain.bind(fn))
110 var disableLongStackTraces = function() {};
111 Promise.longStackTraces = function () {
112 if (async.haveItemsQueued() && !config.longStackTraces) {
113 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
115 if (!config.longStackTraces && longStackTracesIsSupported()) {
116 var Promise_captureStackTrace = Promise.prototype._captureStackTrace;
117 var Promise_attachExtraTrace = Promise.prototype._attachExtraTrace;
118 config.longStackTraces = true;
119 disableLongStackTraces = function() {
120 if (async.haveItemsQueued() && !config.longStackTraces) {
121 throw new Error("cannot enable long stack traces after promises have been created\u000a\u000a See http://goo.gl/MqrFmX\u000a");
123 Promise.prototype._captureStackTrace = Promise_captureStackTrace;
124 Promise.prototype._attachExtraTrace = Promise_attachExtraTrace;
125 Context.deactivateLongStackTraces();
126 async.enableTrampoline();
127 config.longStackTraces = false;
129 Promise.prototype._captureStackTrace = longStackTracesCaptureStackTrace;
130 Promise.prototype._attachExtraTrace = longStackTracesAttachExtraTrace;
131 Context.activateLongStackTraces();
132 async.disableTrampolineIfNecessary();
136 Promise.hasLongStackTraces = function () {
137 return config.longStackTraces && longStackTracesIsSupported();
140 Promise.config = function(opts) {
142 if ("longStackTraces" in opts) {
143 if (opts.longStackTraces) {
144 Promise.longStackTraces();
145 } else if (!opts.longStackTraces && Promise.hasLongStackTraces()) {
146 disableLongStackTraces();
149 if ("warnings" in opts) {
150 var warningsOption = opts.warnings;
151 config.warnings = !!warningsOption;
152 wForgottenReturn = config.warnings;
154 if (util.isObject(warningsOption)) {
155 if ("wForgottenReturn" in warningsOption) {
156 wForgottenReturn = !!warningsOption.wForgottenReturn;
160 if ("cancellation" in opts && opts.cancellation && !config.cancellation) {
161 if (async.haveItemsQueued()) {
163 "cannot enable cancellation after promises are in use");
165 Promise.prototype._clearCancellationData =
166 cancellationClearCancellationData;
167 Promise.prototype._propagateFrom = cancellationPropagateFrom;
168 Promise.prototype._onCancel = cancellationOnCancel;
169 Promise.prototype._setOnCancel = cancellationSetOnCancel;
170 Promise.prototype._attachCancellationCallback =
171 cancellationAttachCancellationCallback;
172 Promise.prototype._execute = cancellationExecute;
173 propagateFromFunction = cancellationPropagateFrom;
174 config.cancellation = true;
178 Promise.prototype._execute = function(executor, resolve, reject) {
180 executor(resolve, reject);
185 Promise.prototype._onCancel = function () {};
186 Promise.prototype._setOnCancel = function (handler) { ; };
187 Promise.prototype._attachCancellationCallback = function(onCancel) {
190 Promise.prototype._captureStackTrace = function () {};
191 Promise.prototype._attachExtraTrace = function () {};
192 Promise.prototype._clearCancellationData = function() {};
193 Promise.prototype._propagateFrom = function (parent, flags) {
198 function cancellationExecute(executor, resolve, reject) {
201 executor(resolve, reject, function(onCancel) {
202 if (typeof onCancel !== "function") {
203 throw new TypeError("onCancel must be a function, got: " +
204 util.toString(onCancel));
206 promise._attachCancellationCallback(onCancel);
213 function cancellationAttachCancellationCallback(onCancel) {
214 if (!this.isCancellable()) return this;
216 var previousOnCancel = this._onCancel();
217 if (previousOnCancel !== undefined) {
218 if (util.isArray(previousOnCancel)) {
219 previousOnCancel.push(onCancel);
221 this._setOnCancel([previousOnCancel, onCancel]);
224 this._setOnCancel(onCancel);
228 function cancellationOnCancel() {
229 return this._onCancelField;
232 function cancellationSetOnCancel(onCancel) {
233 this._onCancelField = onCancel;
236 function cancellationClearCancellationData() {
237 this._cancellationParent = undefined;
238 this._onCancelField = undefined;
241 function cancellationPropagateFrom(parent, flags) {
242 if ((flags & 1) !== 0) {
243 this._cancellationParent = parent;
244 var branchesRemainingToCancel = parent._branchesRemainingToCancel;
245 if (branchesRemainingToCancel === undefined) {
246 branchesRemainingToCancel = 0;
248 parent._branchesRemainingToCancel = branchesRemainingToCancel + 1;
250 if ((flags & 2) !== 0 && parent._isBound()) {
251 this._setBoundTo(parent._boundTo);
255 function bindingPropagateFrom(parent, flags) {
256 if ((flags & 2) !== 0 && parent._isBound()) {
257 this._setBoundTo(parent._boundTo);
260 var propagateFromFunction = bindingPropagateFrom;
262 function boundValueFunction() {
263 var ret = this._boundTo;
264 if (ret !== undefined) {
265 if (ret instanceof Promise) {
266 if (ret.isFulfilled()) {
276 function longStackTracesCaptureStackTrace() {
277 this._trace = new CapturedTrace(this._peekContext());
280 function longStackTracesAttachExtraTrace(error, ignoreSelf) {
281 if (canAttachTrace(error)) {
282 var trace = this._trace;
283 if (trace !== undefined) {
284 if (ignoreSelf) trace = trace._parent;
286 if (trace !== undefined) {
287 trace.attachExtraTrace(error);
288 } else if (!error.__stackCleaned__) {
289 var parsed = parseStackAndMessage(error);
290 util.notEnumerableProp(error, "stack",
291 parsed.message + "\n" + parsed.stack.join("\n"));
292 util.notEnumerableProp(error, "__stackCleaned__", true);
297 function checkForgottenReturns(returnValue, promiseCreated, name, promise,
299 if (returnValue === undefined && promiseCreated !== null &&
301 if (parent !== undefined && parent._returnedNonUndefined()) return;
303 if (name) name = name + " ";
304 var msg = "a promise was created in a " + name +
305 "handler but was not returned from it";
306 promise._warn(msg, true, promiseCreated);
310 function deprecated(name, replacement) {
312 " is deprecated and will be removed in a future version.";
313 if (replacement) message += " Use " + replacement + " instead.";
314 return warn(message);
317 function warn(message, shouldUseOwnTrace, promise) {
318 if (!config.warnings) return;
319 var warning = new Warning(message);
321 if (shouldUseOwnTrace) {
322 promise._attachExtraTrace(warning);
323 } else if (config.longStackTraces && (ctx = Promise._peekContext())) {
324 ctx.attachExtraTrace(warning);
326 var parsed = parseStackAndMessage(warning);
327 warning.stack = parsed.message + "\n" + parsed.stack.join("\n");
329 formatAndLogError(warning, "", true);
332 function reconstructStack(message, stacks) {
333 for (var i = 0; i < stacks.length - 1; ++i) {
334 stacks[i].push("From previous event:");
335 stacks[i] = stacks[i].join("\n");
337 if (i < stacks.length) {
338 stacks[i] = stacks[i].join("\n");
340 return message + "\n" + stacks.join("\n");
343 function removeDuplicateOrEmptyJumps(stacks) {
344 for (var i = 0; i < stacks.length; ++i) {
345 if (stacks[i].length === 0 ||
346 ((i + 1 < stacks.length) && stacks[i][0] === stacks[i+1][0])) {
353 function removeCommonRoots(stacks) {
354 var current = stacks[0];
355 for (var i = 1; i < stacks.length; ++i) {
356 var prev = stacks[i];
357 var currentLastIndex = current.length - 1;
358 var currentLastLine = current[currentLastIndex];
359 var commonRootMeetPoint = -1;
361 for (var j = prev.length - 1; j >= 0; --j) {
362 if (prev[j] === currentLastLine) {
363 commonRootMeetPoint = j;
368 for (var j = commonRootMeetPoint; j >= 0; --j) {
370 if (current[currentLastIndex] === line) {
381 function cleanStack(stack) {
383 for (var i = 0; i < stack.length; ++i) {
385 var isTraceLine = " (No stack trace)" === line ||
386 stackFramePattern.test(line);
387 var isInternalFrame = isTraceLine && shouldIgnore(line);
388 if (isTraceLine && !isInternalFrame) {
389 if (indentStackFrames && line.charAt(0) !== " ") {
398 function stackFramesAsArray(error) {
399 var stack = error.stack.replace(/\s+$/g, "").split("\n");
400 for (var i = 0; i < stack.length; ++i) {
402 if (" (No stack trace)" === line || stackFramePattern.test(line)) {
407 stack = stack.slice(i);
412 function parseStackAndMessage(error) {
413 var stack = error.stack;
414 var message = error.toString();
415 stack = typeof stack === "string" && stack.length > 0
416 ? stackFramesAsArray(error) : [" (No stack trace)"];
419 stack: cleanStack(stack)
423 function formatAndLogError(error, title, isSoft) {
424 if (typeof console !== "undefined") {
426 if (util.isObject(error)) {
427 var stack = error.stack;
428 message = title + formatStack(stack, error);
430 message = title + String(error);
432 if (typeof printWarning === "function") {
433 printWarning(message, isSoft);
434 } else if (typeof console.log === "function" ||
435 typeof console.log === "object") {
436 console.log(message);
441 function fireRejectionEvent(name, localHandler, reason, promise) {
442 var localEventFired = false;
444 if (typeof localHandler === "function") {
445 localEventFired = true;
446 if (name === "rejectionHandled") {
447 localHandler(promise);
449 localHandler(reason, promise);
456 var globalEventFired = false;
458 globalEventFired = fireGlobalEvent(name, reason, promise);
460 globalEventFired = true;
464 var domEventFired = false;
467 domEventFired = fireDomEvent(name.toLowerCase(), {
472 domEventFired = true;
477 if (!globalEventFired && !localEventFired && !domEventFired &&
478 name === "unhandledRejection") {
479 formatAndLogError(reason, "Unhandled rejection ");
483 function formatNonError(obj) {
485 if (typeof obj === "function") {
487 (obj.name || "anonymous") +
490 str = obj && typeof obj.toString === "function"
491 ? obj.toString() : util.toString(obj);
492 var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
493 if (ruselessToString.test(str)) {
495 var newStr = JSON.stringify(obj);
502 if (str.length === 0) {
503 str = "(empty array)";
506 return ("(<" + snip(str) + ">, no stack trace)");
511 if (str.length < maxChars) {
514 return str.substr(0, maxChars - 3) + "...";
517 function longStackTracesIsSupported() {
518 return typeof captureStackTrace === "function";
521 var shouldIgnore = function() { return false; };
522 var parseLineInfoRegex = /[\/<\(]([^:\/]+):(\d+):(?:\d+)\)?\s*$/;
523 function parseLineInfo(line) {
524 var matches = line.match(parseLineInfoRegex);
527 fileName: matches[1],
528 line: parseInt(matches[2], 10)
533 function setBounds(firstLineError, lastLineError) {
534 if (!longStackTracesIsSupported()) return;
535 var firstStackLines = firstLineError.stack.split("\n");
536 var lastStackLines = lastLineError.stack.split("\n");
541 for (var i = 0; i < firstStackLines.length; ++i) {
542 var result = parseLineInfo(firstStackLines[i]);
544 firstFileName = result.fileName;
545 firstIndex = result.line;
549 for (var i = 0; i < lastStackLines.length; ++i) {
550 var result = parseLineInfo(lastStackLines[i]);
552 lastFileName = result.fileName;
553 lastIndex = result.line;
557 if (firstIndex < 0 || lastIndex < 0 || !firstFileName || !lastFileName ||
558 firstFileName !== lastFileName || firstIndex >= lastIndex) {
562 shouldIgnore = function(line) {
563 if (bluebirdFramePattern.test(line)) return true;
564 var info = parseLineInfo(line);
566 if (info.fileName === firstFileName &&
567 (firstIndex <= info.line && info.line <= lastIndex)) {
575 function CapturedTrace(parent) {
576 this._parent = parent;
577 this._promisesCreated = 0;
578 var length = this._length = 1 + (parent === undefined ? 0 : parent._length);
579 captureStackTrace(this, CapturedTrace);
580 if (length > 32) this.uncycle();
582 util.inherits(CapturedTrace, Error);
583 Context.CapturedTrace = CapturedTrace;
585 CapturedTrace.prototype.uncycle = function() {
586 var length = this._length;
587 if (length < 2) return;
589 var stackToIndex = {};
591 for (var i = 0, node = this; node !== undefined; ++i) {
595 length = this._length = i;
596 for (var i = length - 1; i >= 0; --i) {
597 var stack = nodes[i].stack;
598 if (stackToIndex[stack] === undefined) {
599 stackToIndex[stack] = i;
602 for (var i = 0; i < length; ++i) {
603 var currentStack = nodes[i].stack;
604 var index = stackToIndex[currentStack];
605 if (index !== undefined && index !== i) {
607 nodes[index - 1]._parent = undefined;
608 nodes[index - 1]._length = 1;
610 nodes[i]._parent = undefined;
611 nodes[i]._length = 1;
612 var cycleEdgeNode = i > 0 ? nodes[i - 1] : this;
614 if (index < length - 1) {
615 cycleEdgeNode._parent = nodes[index + 1];
616 cycleEdgeNode._parent.uncycle();
617 cycleEdgeNode._length =
618 cycleEdgeNode._parent._length + 1;
620 cycleEdgeNode._parent = undefined;
621 cycleEdgeNode._length = 1;
623 var currentChildLength = cycleEdgeNode._length + 1;
624 for (var j = i - 2; j >= 0; --j) {
625 nodes[j]._length = currentChildLength;
626 currentChildLength++;
633 CapturedTrace.prototype.attachExtraTrace = function(error) {
634 if (error.__stackCleaned__) return;
636 var parsed = parseStackAndMessage(error);
637 var message = parsed.message;
638 var stacks = [parsed.stack];
641 while (trace !== undefined) {
642 stacks.push(cleanStack(trace.stack.split("\n")));
643 trace = trace._parent;
645 removeCommonRoots(stacks);
646 removeDuplicateOrEmptyJumps(stacks);
647 util.notEnumerableProp(error, "stack", reconstructStack(message, stacks));
648 util.notEnumerableProp(error, "__stackCleaned__", true);
651 var captureStackTrace = (function stackDetection() {
652 var v8stackFramePattern = /^\s*at\s*/;
653 var v8stackFormatter = function(stack, error) {
654 if (typeof stack === "string") return stack;
656 if (error.name !== undefined &&
657 error.message !== undefined) {
658 return error.toString();
660 return formatNonError(error);
663 if (typeof Error.stackTraceLimit === "number" &&
664 typeof Error.captureStackTrace === "function") {
665 Error.stackTraceLimit += 6;
666 stackFramePattern = v8stackFramePattern;
667 formatStack = v8stackFormatter;
668 var captureStackTrace = Error.captureStackTrace;
670 shouldIgnore = function(line) {
671 return bluebirdFramePattern.test(line);
673 return function(receiver, ignoreUntil) {
674 Error.stackTraceLimit += 6;
675 captureStackTrace(receiver, ignoreUntil);
676 Error.stackTraceLimit -= 6;
679 var err = new Error();
681 if (typeof err.stack === "string" &&
682 err.stack.split("\n")[0].indexOf("stackDetection@") >= 0) {
683 stackFramePattern = /@/;
684 formatStack = v8stackFormatter;
685 indentStackFrames = true;
686 return function captureStackTrace(o) {
687 o.stack = new Error().stack;
691 var hasStackAfterThrow;
692 try { throw new Error(); }
694 hasStackAfterThrow = ("stack" in e);
696 if (!("stack" in err) && hasStackAfterThrow &&
697 typeof Error.stackTraceLimit === "number") {
698 stackFramePattern = v8stackFramePattern;
699 formatStack = v8stackFormatter;
700 return function captureStackTrace(o) {
701 Error.stackTraceLimit += 6;
702 try { throw new Error(); }
703 catch(e) { o.stack = e.stack; }
704 Error.stackTraceLimit -= 6;
708 formatStack = function(stack, error) {
709 if (typeof stack === "string") return stack;
711 if ((typeof error === "object" ||
712 typeof error === "function") &&
713 error.name !== undefined &&
714 error.message !== undefined) {
715 return error.toString();
717 return formatNonError(error);
725 var fireGlobalEvent = (function() {
727 return function(name, reason, promise) {
728 if (name === "rejectionHandled") {
729 return process.emit(name, promise);
731 return process.emit(name, reason, promise);
735 var globalObject = typeof self !== "undefined" ? self :
736 typeof window !== "undefined" ? window :
737 typeof global !== "undefined" ? global :
738 this !== undefined ? this : null;
747 var event = document.createEvent("CustomEvent");
748 event.initCustomEvent("testingtheevent", false, true, {});
749 globalObject.dispatchEvent(event);
750 fireDomEvent = function(type, detail) {
751 var event = document.createEvent("CustomEvent");
752 event.initCustomEvent(type, false, true, detail);
753 return !globalObject.dispatchEvent(event);
757 var toWindowMethodNameMap = {};
758 toWindowMethodNameMap["unhandledRejection"] = ("on" +
759 "unhandledRejection").toLowerCase();
760 toWindowMethodNameMap["rejectionHandled"] = ("on" +
761 "rejectionHandled").toLowerCase();
763 return function(name, reason, promise) {
764 var methodName = toWindowMethodNameMap[name];
765 var method = globalObject[methodName];
766 if (!method) return false;
767 if (name === "rejectionHandled") {
768 method.call(globalObject, promise);
770 method.call(globalObject, reason, promise);
777 if (typeof console !== "undefined" && typeof console.warn !== "undefined") {
778 printWarning = function (message) {
779 console.warn(message);
781 if (util.isNode && process.stderr.isTTY) {
782 printWarning = function(message, isSoft) {
783 var color = isSoft ? "\u001b[33m" : "\u001b[31m";
784 console.warn(color + message + "\u001b[0m\n");
786 } else if (!util.isNode && typeof (new Error().stack) === "string") {
787 printWarning = function(message, isSoft) {
788 console.warn("%c" + message,
789 isSoft ? "color: darkorange" : "color: red");
796 longStackTraces: false,
800 if (longStackTraces) Promise.longStackTraces();
803 longStackTraces: function() {
804 return config.longStackTraces;
806 warnings: function() {
807 return config.warnings;
809 cancellation: function() {
810 return config.cancellation;
812 propagateFromFunction: function() {
813 return propagateFromFunction;
815 boundValueFunction: function() {
816 return boundValueFunction;
818 checkForgottenReturns: checkForgottenReturns,
819 setBounds: setBounds,
821 deprecated: deprecated,
822 CapturedTrace: CapturedTrace