Regenerate nvim config

config/neovim/store/lazy-plugins/promise-async/spec/helpers/basics.lua

@@ -0,0 +1,30 @@
+local Basic = {}
+
+local co = coroutine.create(function() end)
+coroutine.resume(co)
+
+Basic['`nil`'] = function()
+    return nil
+end
+
+Basic['`false`'] = function()
+    return false
+end
+
+Basic['`0`'] = function()
+    return 0
+end
+
+Basic['`string`'] = function()
+    return 'string'
+end
+
+Basic['a metatable'] = function()
+    return setmetatable({}, {})
+end
+
+Basic['a thread'] = function()
+    return co
+end
+
+return Basic

config/neovim/store/lazy-plugins/promise-async/spec/helpers/init.lua

@@ -0,0 +1,58 @@
+local M = {}
+local promise = require('promise')
+
+M.setTimeout = promise.loop.setTimeout
+
+function M.deferredPromise()
+    local resolve, reject
+    local p = promise(function(resolve0, reject0)
+        resolve, reject = resolve0, reject0
+    end)
+    return p, resolve, reject
+end
+
+function M.testFulfilled(it, assert, value, test)
+    it('already-fulfilled', function()
+        test(promise.resolve(value))
+        assert.True(wait())
+    end)
+
+    it('immediately-fulfilled', function()
+        local p, resolve = M.deferredPromise()
+        test(p)
+        resolve(value)
+        assert.True(wait())
+    end)
+
+    it('eventually-fulfilled', function()
+        local p, resolve = M.deferredPromise()
+        test(p)
+        wait(10)
+        resolve(value)
+        assert.True(wait())
+    end)
+end
+
+function M.testRejected(it, assert, reason, test)
+    it('already-rejected', function()
+        test(promise.reject(reason))
+        assert.True(wait())
+    end)
+
+    it('immediately-rejected', function()
+        local p, _, reject = M.deferredPromise()
+        test(p)
+        reject(reason)
+        assert.True(wait())
+    end)
+
+    it('eventually-fulfilled', function()
+        local p, _, reject = M.deferredPromise()
+        test(p)
+        wait(10)
+        reject(reason)
+        assert.True(wait())
+    end)
+end
+
+return M

config/neovim/store/lazy-plugins/promise-async/spec/helpers/outputHandler.lua

@@ -0,0 +1,29 @@
+return function(options)
+    local busted = require('busted')
+    local handler = require('busted.outputHandlers.utfTerminal')(options)
+
+    local promiseUnhandledError = {}
+
+    busted.subscribe({'test', 'end'}, function(element, parent)
+        while #promiseUnhandledError > 0 do
+            local res = table.remove(promiseUnhandledError, 1)
+            handler.successesCount = handler.successesCount - 1
+            handler.failuresCount = handler.failuresCount + 1
+            busted.publish({'failure', element.descriptor}, element, parent, tostring(res))
+        end
+    end)
+
+    require('promise').loop.callWrapper = function(callback)
+        local ok, res = pcall(callback)
+        if ok then
+            return
+        end
+        -- Some tests never handle the rejected promises, We should ignore them.
+        local msg = tostring(res)
+        if msg:match('^UnhandledPromiseRejection') then
+            return
+        end
+        table.insert(promiseUnhandledError, msg)
+    end
+    return handler
+end

config/neovim/store/lazy-plugins/promise-async/spec/helpers/reasons.lua

@@ -0,0 +1,37 @@
+local promise = require('promise')
+local Reasons = {}
+local dummy = {dummy = 'dummy'}
+
+Reasons['`nil`'] = function()
+    return nil
+end
+
+Reasons['`false`'] = function()
+    return false
+end
+
+-- Lua before 5.3 versions will transfer number to string after pcall.
+-- Pure string will carry some extra information after pcall, no need to test
+-- Reasons['`0`'] = function()
+--     return 0
+-- end
+
+Reasons['a metatable'] = function()
+    return setmetatable({}, {})
+end
+
+Reasons['an always-pending thenable'] = function()
+    return {
+        thenCall = function() end
+    }
+end
+
+Reasons['a fulfilled promise'] = function()
+    return promise.resolve(dummy)
+end
+
+Reasons['a rejected promise'] = function()
+    return promise.reject(dummy)
+end
+
+return Reasons

config/neovim/store/lazy-plugins/promise-async/spec/helpers/thenables.lua

@@ -0,0 +1,137 @@
+local helpers = require('spec.helpers.init')
+local setTimeout = helpers.setTimeout
+local deferredPromise = helpers.deferredPromise
+local promise = require('promise')
+local other = {other = 'other'}
+
+local Thenables = {
+    fulfilled = {
+        ['a synchronously-fulfilled custom thenable'] = function(value)
+            return {
+                thenCall = function(self, resolvePromise)
+                    local _ = self
+                    resolvePromise(value)
+                end
+            }
+        end,
+        ['an asynchronously-fulfilled custom thenable'] = function(value)
+            return {
+                thenCall = function(self, resolvePromise)
+                    local _ = self
+                    setTimeout(function()
+                        resolvePromise(value)
+                    end, 0)
+                end
+            }
+        end,
+        ['a synchronously-fulfilled one-time thenable'] = function(value)
+            local numberOfTimesThenRetrieved = 0;
+            return setmetatable({}, {
+                __index = function(_, k)
+                    if numberOfTimesThenRetrieved == 0 and k == 'thenCall' then
+                        numberOfTimesThenRetrieved = numberOfTimesThenRetrieved + 1
+                        return function(self, resolvePromise)
+                            local _ = self
+                            resolvePromise(value)
+                        end
+                    end
+                    return nil
+                end
+            })
+        end,
+        ['a thenable that tries to fulfill twice'] = function(value)
+            return {
+                thenCall = function(self, resolvePromise)
+                    local _ = self
+                    resolvePromise(value)
+                    resolvePromise(other)
+                end
+            }
+        end,
+        ['a thenable that fulfills but then throws'] = function(value)
+            return {
+                thenCall = function(self, resolvePromise)
+                    local _ = self
+                    resolvePromise(value)
+                    error(other)
+                end
+            }
+        end,
+        ['an already-fulfilled promise'] = function(value)
+            return promise.resolve(value)
+        end,
+        ['an eventually-fulfilled promise'] = function(value)
+            local p, resolve = deferredPromise()
+            setTimeout(function()
+                resolve(value)
+            end, 10)
+            return p
+        end
+    },
+    rejected = {
+        ['a synchronously-rejected custom thenable'] = function(reason)
+            return {
+                thenCall = function(self, resolvePromise, rejectPromise)
+                    local _, _ = self, resolvePromise
+                    rejectPromise(reason)
+                end
+            }
+        end,
+        ['an asynchronously-rejected custom thenable'] = function(reason)
+            return {
+                thenCall = function(self, resolvePromise, rejectPromise)
+                    local _, _ = self, resolvePromise
+                    setTimeout(function()
+                        rejectPromise(reason)
+                    end, 0)
+                end
+            }
+        end,
+        ['a synchronously-rejected one-time thenable'] = function(reason)
+            local numberOfTimesThenRetrieved = 0;
+            return setmetatable({}, {
+                __index = function(_, k)
+                    if numberOfTimesThenRetrieved == 0 and k == 'thenCall' then
+                        numberOfTimesThenRetrieved = numberOfTimesThenRetrieved + 1
+                        return function(self, resolvePromise, rejectPromise)
+                            local _, _ = self, resolvePromise
+                            rejectPromise(reason)
+                        end
+                    end
+                    return nil
+                end
+            })
+        end,
+        ['a thenable that immediately throws in `thenCall`'] = function(reason)
+            return {
+                thenCall = function()
+                    error(reason)
+                end
+            }
+        end,
+        ['an table with a throwing `thenCall` metatable'] = function(reason)
+            return setmetatable({}, {
+                __index = function(_, k)
+                    if k == 'thenCall' then
+                        return function()
+                            error(reason)
+                        end
+                    end
+                    return nil
+                end
+            })
+        end,
+        ['an already-rejected promise'] = function(reason)
+            return promise.reject(reason)
+        end,
+        ['an eventually-rejected promise'] = function(reason)
+            local p, _, reject = deferredPromise()
+            setTimeout(function()
+                reject(reason)
+            end, 10)
+            return p
+        end
+    }
+}
+
+return Thenables