initial commit, no substantial code changes

Author: omniraptorr

Promise.lua

@@ -16,20 +16,25 @@
 --	promise:andThen(onFulfilled1):andThen(onFulfilled2, onRejected2)
 --
 -- History:
---	2015.10.29	release v1.1, fix some bugs and update testcases
---	2015.08.10	release v1.0.1, full testcases, minor fix and publish on github
+--	2015.10.29	release v1.1, fix some bugs and update test cases
+--	2015.08.10	release v1.0.1, full test cases, minor fix and publish on github
 --	2015.03		release v1.0.0
 -----------------------------------------------------------------------------
 
-local Promise, promise = {}, {}
+local Promise = {}
+
+---@class Promise
+local promise = {}
 
 -- andThen replacer
 --  1) replace standard .then() when promised
 local PENDING = {}
 local nil_promise = {}
 
+
 local function promised(value, action)
 	local ok, result = pcall(action, value)
+	--print("Called handler with " .. tostring(value) .. " received " .. tostring(ok) .. " + " .. tostring(value))
 	return ok and Promise.resolve(result) or Promise.reject(result) -- .. '.\n' .. debug.traceback())
 end
 
@@ -45,7 +50,7 @@ local function promised_n(self, _, onRejected)
 	return onRejected and promised(self[1], onRejected) or self
 end
 
--- inext() list all elementys in array
+-- inext() list all elements in array
 --	*) next() will list all members for table without order
 --	*) @see iter(): http://www.lua.org/pil/7.3.html
 local function inext(a, i)
@@ -55,10 +60,11 @@ local function inext(a, i)
 end
 -- put resolved value to p[1], or push lazyed calls/object to p[]
 --	1) if resolved a no pending promise, direct call promise.andThen()
+---@param resolved Promise
 local function resolver(this, resolved, sure)
 	local typ = type(resolved)
 	if (typ == 'table' and resolved.andThen) then
-		local lazy = {this,
+		local lazy = --[[---@type Promise ]] {this,
 			function(value) return resolver(this, value, true) end,
 			function(reason) return resolver(this, reason, false) end}
 		if resolved[1] == PENDING then
@@ -119,12 +125,22 @@ setmetatable(nil_promise, promise)
 --	2) promise:catch(onRejected)
 ------------------------------------------------------------------------------------------
 
+-- Creates a new promise instance in the pending state
+-- from the fulfill and the reject functions.
+
+---@param onFulfilled function | nil
+---@param onRejected function | nil
+---@return Promise
 function promise:andThen(onFulfilled, onRejected)
-	local lazy = {{PENDING}, onFulfilled, onRejected}
-	table.insert(self, lazy)
+	local lazy = --[[---@type Promise ]] {{PENDING}, onFulfilled, onRejected}
+	table.insert(--[[---@type Promise[] ]] self, lazy)
 	return setmetatable(lazy[1], promise) -- <lazy[1]> is promise2
 end
 
+-- Creates a new promise instance in the pending state
+-- from just the reject function.
+---@param onRejected function
+---@return Promise
 function promise:catch(onRejected)
 	return self:andThen(nil, onRejected)
 end

README.md

@@ -100,31 +100,31 @@ This is a base testcase:
 ---
 Promise = require('Promise')
 
-A = function() return 10 end
-B = function(a) print(a * 2) end
-C = function(a)
+return10 = function() return 10 end
+returnDoubled = function(a) print(a * 2) end
+printX4 = function(a)
 	print(a * 4)
 	return Promise.resolve('ok')  -- or direct return 'ok'
 end
-D = function(a) print(a * 3) end
-E = function(result)
+printX3 = function(a) print(a * 3) end
+unpackAndReject = function(result)
 	local b, c, d = unpack(result)
 	print(b, c, d)
 	return Promise.reject('FIRE')
 end
 
 -- promise_A = Promise.resolve(A())
-promise_A = Promise.new(function(resolve, reject)
-	local ok, result = pcall(A)
+promise_r10 = Promise.new(function(resolve, reject)
+	local ok, result = pcall(return10)
 	return (ok and resolve or reject)(result)
 end)
-promise_B = promise_A:andThen(B)
-promise_C = promise_A:andThen(C)
-promise_D = promise_A:andThen(D)
+promise_B = promise_r10:andThen(returnDoubled)
+promise_C = promise_r10:andThen(printX4)
+promise_D = promise_r10:andThen(printX3)
 
 promises = {promise_B, promise_C, promise_D}
 Promise.all(promises)
-	:andThen(E)
+	:andThen(unpackAndReject)
 	:catch(function(reson)
 		print(reson)
 	end)

testcase/t_base_test.lua

@@ -12,37 +12,43 @@
 --		FIRE
 ---------------------------------------------------------------
 
--- Promise = require('Promise')
-Promise = dofile('../Promise.lua')
+local inspect = require "IO/inspect"
 
-A = function() return 10 end
-B = function(a) print(a * 2) end
-C = function(a)
+ Promise = require('Promise')
+--Promise = require("promises/Promise/Promise")
+print("---")
+return10 = function() return 10 end
+returnDoubled = function(a) print(a * 2) ; return a * 2 end
+printX4 = function(a)
 	print(a * 4)
-	-- return Promise.resolve('ok')
-	return 'ok'
+	return Promise.resolve('ok')
+	-- return 'ok'
 end
-D = function(a) print(a * 3) end
-E = function(result)
+printX3 = function(a) print(a * 3) ; return a * 3 end
+unpackAndReject = function(result)
 	local b, c, d = unpack(result)
 	print(b, c, d)
 	return Promise.reject('FIRE')
 end
 
 -- promise_A = Promise.resolve(A())
-promise_A = Promise.new(function(resolve, reject)
-	local ok, result = pcall(A)
+promise_r10 = Promise.new(function(resolve, reject)
+	local ok, result = pcall(return10)
+	print("after pcall " .. tostring(ok) .. " " .. result .. ".")
 	return (ok and resolve or reject)(result)
 end)
+promise_r10 = Promise.resolve(10)
 -- promise_B = promise_A:andThen(B)
 local err = function(r) print("catch:", r) end
 local log = function(r) print("andThen:", r); return r end
-promise_B = promise_A:andThen(B):catch(err):andThen(log)
+promise_B = promise_r10:andThen(returnDoubled):catch(err):andThen(log)
 
-promise_C = promise_A:andThen(C)
-promise_D = promise_A:andThen(D)
+promise_C = promise_r10:andThen(printX4)
+promise_D = promise_r10:andThen(printX3)
 
+
+print(inspect({"hi"}))
 promises = {promise_B, promise_C, promise_D}
-Promise.all(promises)
-	:andThen(E)
+Promise.all(promises):andThen(function(o) print(inspect(o)) return o end)
+	:andThen(unpackAndReject)
 	:catch(print)

testcase/t_rpc_test.lua

@@ -17,12 +17,12 @@
 ---------------------------------------------------------------
 
 -- Promise = require('Promise')
-Promise = dofile('../Promise.lua')
+Promise = dofile('Promise.lua')
 sleep = function(n) os.execute("sleep " .. n) end
 
 local co_remote
-A = function() return 10 end
-B = function(a)
+return10 = function() return 10 end
+returnDoubled = function(a)
 	return Promise.new(function(...)
 		-- start coroutine and wait
 		co_remote = coroutine.create(function(y, n)
@@ -32,32 +32,32 @@ B = function(a)
 		coroutine.resume(co_remote, ...)
 	end)
 end
-C = function(a)
+printX4 = function(a)
 	print(a * 4)
 	return Promise.resolve('ok')
 end
-D = function(a) print(a * 3) end
-E = function(result)
-	local b, c, d = unpack(result)
+printX3 = function(a) print(a * 3) end
+unpackAndReject = function(...)
+	local b, c, d = ...
 	print(b, c, d)
 	return Promise.reject('FIRE')
 end
 
 -- promise_A = Promise.resolve(A())
-promise_A = Promise.new(function(resolve, reject)
-	local ok, result = pcall(A)
+promise_r10 = Promise.new(function(resolve, reject)
+	local ok, result = pcall(return10)
 	return (ok and resolve or reject)(result)
 end)
 
 local err = function(r) print("catch:", r) end
 local log = function(r) print("andThen:", r); return r end
-promise_B = promise_A:andThen(B):catch(err):andThen(log)
-promise_C = promise_A:andThen(C)
-promise_D = promise_A:andThen(D)
+promise_B = promise_r10:andThen(returnDoubled):catch(err):andThen(log)
+promise_C = promise_r10:andThen(printX4)
+promise_D = promise_r10:andThen(printX3)
 
 promises = {promise_B, promise_C, promise_D}
 Promise.all(promises)
-	:andThen(E)
+	:andThen(unpackAndReject)
 	:catch(function(reson)
 		print(reson)
 	end)