Release v0.9.6-0

js/debug/captured_trace.js

@@ -106,9 +106,18 @@ CapturedTrace.isSupported = function CapturedTrace$IsSupported() {
 };
 
 var captureStackTrace = (function stackDetection() {
+    function snip( str ) {
+        var maxChars = 41;
+        if( str.length < maxChars ) {
+            return str;
+        }
+        return str.substr(0, maxChars - 3) + "...";
+    }
+
     function formatNonError( obj ) {
         var str = obj.toString();
-        if( str === "[object Object]") {
+        var ruselessToString = /\[object [a-zA-Z0-9$_]+\]/;
+        if( ruselessToString.test( str ) ) {
             try {
                 var newStr = JSON.stringify(obj);
                 str = newStr;
@@ -117,7 +126,7 @@ var captureStackTrace = (function stackDetection() {
 
             }
         }
-        return ("(<" + str + ">, no stack trace)");
+        return ("(<" + snip( str ) + ">, no stack trace)");
     }
 
     if( typeof Error.stackTraceLimit === "number" &&
@@ -213,4 +222,4 @@ var captureStackTrace = (function stackDetection() {
 })();
 
 return CapturedTrace;
-};
+};

js/debug/errors.js

@@ -21,10 +21,12 @@
  */
 "use strict";
 var global = require("./global.js");
+var Objectfreeze = global.Object.freeze;
 var util = require( "./util.js");
 var inherits = util.inherits;
 var isObject = util.isObject;
 var notEnumerableProp = util.notEnumerableProp;
+var Error = global.Error;
 
 function isStackAttached( val ) {
     return ( val & 1 ) > 0;
@@ -98,10 +100,39 @@ if( typeof TypeError !== "function" ) {
 var CancellationError = subError( "CancellationError", "cancellation error" );
 var TimeoutError = subError( "TimeoutError", "timeout error" );
 
+function RejectionError( message ) {
+    this.name = "RejectionError";
+    this.message = message;
+    this.cause = message;
+
+    if( message instanceof Error ) {
+        this.message = message.message;
+        this.stack = message.stack;
+    }
+    else if( Error.captureStackTrace ) {
+        Error.captureStackTrace( this, this.constructor );
+    }
+
+}
+inherits( RejectionError, Error );
+
+var key = "__BluebirdErrorTypes__";
+var errorTypes = global[key];
+if( !errorTypes ) {
+    errorTypes = Objectfreeze({
+        CancellationError: CancellationError,
+        TimeoutError: TimeoutError,
+        RejectionError: RejectionError
+    });
+    notEnumerableProp( global, key, errorTypes );
+}
+
 module.exports = {
+    Error: Error,
     TypeError: TypeError,
-    CancellationError: CancellationError,
-    TimeoutError: TimeoutError,
+    CancellationError: errorTypes.CancellationError,
+    RejectionError: errorTypes.RejectionError,
+    TimeoutError: errorTypes.TimeoutError,
     attachDefaultState: attachDefaultState,
     ensureNotHandled: ensureNotHandled,
     withHandledUnmarked: withHandledUnmarked,
@@ -110,4 +141,4 @@ module.exports = {
     isStackAttached: isStackAttached,
     isHandled: isHandled,
     canAttach: canAttach
-};
+};

js/debug/promise.js

@@ -45,6 +45,7 @@ var tryCatchApply = util.tryCatchApply;
 var TypeError = errors.TypeError;
 var CancellationError = errors.CancellationError;
 var TimeoutError = errors.TimeoutError;
+var RejectionError = errors.RejectionError;
 var ensureNotHandled = errors.ensureNotHandled;
 var withHandledMarked = errors.withHandledMarked;
 var withStackAttached = errors.withStackAttached;
@@ -1022,7 +1023,10 @@ if( !CapturedTrace.isSupported() ) {
 Promise.CancellationError = CancellationError;
 Promise.TimeoutError = TimeoutError;
 Promise.TypeError = TypeError;
-};/**
+Promise.RejectionError = RejectionError;
+
+};
+/**
  * Copyright (c) 2013 Petka Antonov
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -1069,6 +1073,7 @@ var tryCatchApply = util.tryCatchApply;
 var TypeError = errors.TypeError;
 var CancellationError = errors.CancellationError;
 var TimeoutError = errors.TimeoutError;
+var RejectionError = errors.RejectionError;
 var ensureNotHandled = errors.ensureNotHandled;
 var withHandledMarked = errors.withHandledMarked;
 var withStackAttached = errors.withStackAttached;
@@ -2046,6 +2051,8 @@ if( !CapturedTrace.isSupported() ) {
 Promise.CancellationError = CancellationError;
 Promise.TimeoutError = TimeoutError;
 Promise.TypeError = TypeError;
+Promise.RejectionError = RejectionError;
+
 require('./synchronous_inspection.js')(Promise);
 require('./any.js')(Promise,Promise$_All,PromiseArray);
 require('./call_get.js')(Promise);
@@ -2065,4 +2072,4 @@ require('./complex_thenables.js')(Promise);
 Promise.prototype = Promise.prototype;
 return Promise;
 
-};
+};

js/debug/promise_resolver.js

@@ -21,11 +21,46 @@
  */
 "use strict";
 var util = require( "./util.js" );
+var maybeWrapAsError = util.maybeWrapAsError;
 var errors = require( "./errors.js");
 var TimeoutError = errors.TimeoutError;
+var RejectionError = errors.RejectionError;
 var async = require( "./async.js" );
 var haveGetters = util.haveGetters;
-var nodebackForResolver = util.nodebackForResolver;
+
+function isUntypedError( obj ) {
+    return obj instanceof Error &&
+        Object.getPrototypeOf( obj ) === Error.prototype;
+}
+
+function wrapAsRejectionError( obj ) {
+    if( isUntypedError( obj ) ) {
+        return new RejectionError( obj );
+    }
+    return obj;
+}
+
+function nodebackForResolver( resolver ) {
+    function PromiseResolver$_callback( err, value ) {
+        if( err ) {
+            resolver.reject( wrapAsRejectionError( maybeWrapAsError( err ) ) );
+        }
+        else {
+            if( arguments.length > 2 ) {
+                var len = arguments.length;
+                var val = new Array( len - 1 );
+                for( var i = 1; i < len; ++i ) {
+                    val[ i - 1 ] = arguments[ i ];
+                }
+
+                value = val;
+            }
+            resolver.fulfill( value );
+        }
+    }
+    return PromiseResolver$_callback;
+}
+
 
 var PromiseResolver;
 if( !haveGetters ) {
@@ -47,6 +82,8 @@ if( haveGetters ) {
     });
 }
 
+PromiseResolver._nodebackForResolver = nodebackForResolver;
+
 PromiseResolver.prototype.toString = function PromiseResolver$toString() {
     return "[object PromiseResolver]";
 };