Merge pull request #721 from hrsh7th/promise-on-unhandled-rejection

Add Promise.on_unhandled_rejection

Author: rhysd

autoload/vital/__vital__/Async/Promise.vim

@@ -38,6 +38,7 @@ let s:NOOP = funcref('s:noop')
 
 let s:PROMISE = {
     \   '_state': s:PENDING,
+    \   '_has_floating_child': v:false,
     \   '_children': [],
     \   '_fulfillments': [],
     \   '_rejections': [],
@@ -90,6 +91,9 @@ function! s:_publish(promise, ...) abort
   endif
 
   if empty(a:promise._children)
+    if settled == s:REJECTED && !a:promise._has_floating_child
+      call s:_on_unhandled_rejection(a:promise._result)
+    endif
     return
   endif
 
@@ -270,15 +274,22 @@ 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
   let child = s:new(s:NOOP)
   let l:Res = a:0 > 0 ? a:1 : v:null
   let l:Rej = a:0 > 1 ? a:2 : v:null
   if state == s:FULFILLED
+    let parent._has_floating_child = v:true
     call s:Later.call(funcref('s:_invoke_callback', [state, child, Res, parent._result]))
   elseif state == s:REJECTED
+    let parent._has_floating_child = v:true
     call s:Later.call(funcref('s:_invoke_callback', [state, child, Rej, parent._result]))
   else
     call s:_subscribe(parent, child, Res, Rej)

doc/vital/Async/Promise.txt

@@ -377,6 +377,20 @@ 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.
+	If {callback} throws error, |Async.Promise| does not handle it.
+
+	The {callback} is |Funcref|, it's argument can be unhandled thrown error or unhandled rejected value.
+
+	Note:
+	This callback will called even if you using |Vital.Async.Promise.wait()|.
+	If you want to clear callback, you can use following codes.
+
+>
+	call Promise.on_unhandled_rejection(Promise.noop)
+<
 
 is_promise({value})			*Vital.Async.Promise.is_promise()*
 

test/Async/Promise.vimspec

@@ -804,6 +804,89 @@ Describe Async.Promise
       endif
     End
   End
+
+  Describe .on_unhandled_rejection
+
+    After each
+      call P.on_unhandled_rejection(P.noop)
+    End
+
+    It should call when promise throw error but unhandled
+      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 rejected but unhandled
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.reject({ 'error': 'error' })
+      call s:wait_has_key(l, 'result')
+      Assert HasKey(result, 'error')
+      Assert Equals(result.error, 'error')
+    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 catched rejected promise
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.reject({ 'error': 'error' }).catch({ -> {} })
+      call P.wait(Wait(100))
+      Assert KeyNotExists(l, 'result')
+    End
+
+    It should not call when catched thrown error
+      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
+
+    It should not call when promise does not throw error
+      let l = l:
+      call P.on_unhandled_rejection({ result -> extend(l, { 'result': result }) })
+
+      let p = P.resolve().then({ -> { 'success': 'success' } })
+      call P.wait(Wait(100))
+      Assert KeyNotExists(l, 'result')
+    End
+  End
 End
 
 " vim:et ts=2 sts=2 sw=2 tw=0: