Add Promise.on_unhandled_rejection

Author: hrsh7th

autoload/vital/__vital__/Async/Promise.vim

@@ -90,6 +90,9 @@ function! s:_publish(promise, ...) abort
   endif
 
   if empty(a:promise._children)
+    if settled == s:REJECTED
+      call s:_on_unhandled_rejection(a:promise._result)
+    endif
     return
   endif
 
@@ -270,6 +273,11 @@ function! s:wait(promise, ...) abort
   endif
 endfunction
 
+let s:_on_unhandled_rejection = s:NOOP
+function! s:on_unhandled_rejection(on_unhandled_rejection) abort
+  let s:_on_unhandled_rejection = a:on_unhandled_rejection
+endfunction
+
 function! s:_promise_then(...) dict abort
   let parent = self
   let state = parent._state

doc/vital/Async/Promise.txt

@@ -377,6 +377,13 @@ wait({promise}[, {options}])		*Vital.Async.Promise.wait()*
 	call Promise.wait(p, 1000)
 	" Is equivalent to call Promise.wait(p, {'timeout': 1000})
 >
+on_unhandled_rejection({callback})	*Vital.Async.Promise.on_unhandled_rejection*
+
+ 	Set callback to catch all unhandled rejected promise's result.
+
+	Note:
+	This callback will called even if you using |Vital.Async.Promise.wait()|.
+
 
 is_promise({value})			*Vital.Async.Promise.is_promise()*
 

test/Async/Promise.vimspec

@@ -804,6 +804,56 @@ Describe Async.Promise
       endif
     End
   End
+
+  Describe .on_unhandled_rejection
+    It should call when promsie does not catch
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> execute('throw "error"') })
+      call s:wait_has_key(l, 'result')
+      Assert HasKey(result, 'exception')
+      Assert HasKey(result, 'throwpoint')
+    End
+
+    It should call when promise does not catch with finally
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> execute('throw "error"') }).finally({ -> {} })
+      call s:wait_has_key(l, 'result')
+      Assert HasKey(result, 'exception')
+      Assert HasKey(result, 'throwpoint')
+    End
+
+    It should call when promise does not catch with children
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> execute('throw "error"') }).then({ -> {} })
+      call s:wait_has_key(l, 'result')
+      Assert HasKey(result, 'exception')
+      Assert HasKey(result, 'throwpoint')
+    End
+
+    It should call when promise does not catch with wait
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> execute('throw "error"') }).then({ -> {} })
+      let [_, error] = P.wait(p)
+      Assert Equals(error, result)
+    End
+
+    It should not call when promise catched
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> execute('throw "error"') }).catch({ -> {} })
+      call P.wait(Wait(100))
+      Assert KeyNotExists(l, 'result')
+    End
+  End
 End
 
 " vim:et ts=2 sts=2 sw=2 tw=0: