nearly Promises/A+ compliant via Promiz.mithril.js

mithril.js

@@ -509,49 +509,157 @@ Mithril = m = new function app(window) {
 	}
 
 	var none = {}
-	m.deferred = function() {
+	m.deferred = function () {
-		var resolvers = [], rejecters = [], resolved = none, rejected = none, promise = m.prop()
+
-		var object = {
+		// Promiz.mithril.js | Zolmeister | MIT
-			resolve: function(value) {
+		function Deferred(fn, er) {
-				if (resolved === none) promise(resolved = value)
+			// states
-				for (var i = 0; i < resolvers.length; i++) resolvers[i](value)
+			// 0: pending
-				resolvers.length = rejecters.length = 0
+			// 1: resolving
-			},
+			// 2: rejecting
-			reject: function(value) {
+			// 3: resolved
-				if (rejected === none) rejected = value
+			// 4: rejected
-				for (var i = 0; i < rejecters.length; i++) rejecters[i](value)
+			var self = this,
-				resolvers.length = rejecters.length = 0
+				state = 0,
-			},
+				val = 0,
-			promise: promise
+				next = [];
-		}
+
-		object.promise.resolvers = resolvers
+			self['promise'] = self
-		object.promise.then = function(success, error) {
+
-			var next = m.deferred()
+			self['resolve'] = function (v) {
-			if (!success) success = identity
+				if (!state) {
-			if (!error) error = identity
+					val = v
-			function callback(method, callback) {
+					state = 1
-				return function(value) {
+
-					try {
+					fire()
-						var result = callback(value)
-						if (result && typeof result.then == "function") result.then(next[method], error)
-						else next[method](result !== undefined ? result : value)
-					}
-					catch (e) {
-						if (e instanceof Error && e.constructor !== Error) throw e
-						else next.reject(e)
-					}
 				}
+				return this
 			}
-			if (resolved !== none) callback("resolve", success)(resolved)
+
-			else if (rejected !== none) callback("reject", error)(rejected)
+			self['reject'] = function (v) {
-			else {
+				if (!state) {
-				resolvers.push(callback("resolve", success))
+					val = v
-				rejecters.push(callback("reject", error))
+					state = 2
+
+					fire()
+				}
+				return this
+			}
+
+			self['then'] = function (fn, er) {
+				var d = new Deferred(fn, er)
+				if (state == 3) {
+					d.resolve(val)
+				}
+				else if (state == 4) {
+					d.reject(val)
+				}
+				else {
+					next.push(d)
+				}
+				return d
+			}
+
+			var finish = function (type) {
+				state = type || 4
+				next.map(function (p) {
+					state == 3 && p.resolve(val) || p.reject(val)
+				})
+			}
+
+			// ref : reference to 'then' function
+			// cb, ec, cn : successCallback, failureCallback, notThennableCallback
+			function thennable (ref, cb, ec, cn) {
+				if ((typeof val == 'object' || typeof val == 'function') && typeof ref == 'function') {
+					try {
+
+						// cnt protects against abuse calls from spec checker
+						var cnt = 0
+						ref.call(val, function (v) {
+							if (cnt++) return
+							val = v
+							cb()
+						}, function (v) {
+							if (cnt++) return
+							val = v
+							ec()
+						})
+					} catch (e) {
+						val = e
+						ec()
+					}
+				} else {
+					cn()
+				}
+			};
+
+			function fire() {
+
+				// check if it's a thenable
+				var ref;
+				try {
+					ref = val && val.then
+				} catch (e) {
+					val = e
+					state = 2
+					return fire()
+				}
+				thennable(ref, function () {
+					state = 1
+					fire()
+				}, function () {
+					state = 2
+					fire()
+				}, function () {
+					try {
+						if (state == 1 && typeof fn == 'function') {
+							val = fn(val)
+						}
+
+						else if (state == 2 && typeof er == 'function') {
+							val = er(val)
+							state = 1
+						}
+					} catch (e) {
+						val = e
+						return finish()
+					}
+
+					if (val == self) {
+						val = TypeError()
+						finish()
+					} else thennable(ref, function () {
+							finish(3)
+						}, finish, function () {
+							finish(state == 1 && 3)
+						})
+
+				})
 			}
-			return next.promise
 		}
-		return object
+
-	}
+		function newPromisedProp(prop, promise) {
+			prop.then = function () {
+				var newProp = m.prop(prop())
+				return newPromisedProp(newProp,
+					promise.then.apply(promise, arguments).then(newProp))
+			}
+			prop.promise = prop
+			prop.resolve = function (val) {
+				prop(val)
+				promise = promise.resolve.apply(promise, arguments)
+				return prop
+			}
+			prop.reject = function () {
+				promise = promise.reject.apply(promise, arguments)
+				return prop
+			}
+
+			return prop
+		}
+
+    return newPromisedProp(m.prop(), new Deferred())
+  }
 	m.sync = function(args) {
 		var method = "resolve"
 		function synchronizer(pos, resolved) {

tests/mithril-tests.js

@@ -1322,7 +1322,7 @@ function testMithril(mock) {
 		var error = m.prop("no error")
 		var prop = m.request({method: "GET", url: "test", deserialize: function() {throw new Error("error occurred")}}).then(null, error)
 		mock.XMLHttpRequest.$instances.pop().onreadystatechange()
-		return prop() === undefined && error().message === "error occurred"
+		return prop().message === "error occurred" && error().message === "error occurred"
 	})
 	test(function() {
 		var error = m.prop("no error"), exception
@@ -1365,7 +1365,7 @@ function testMithril(mock) {
 	test(function() {
 		var value
 		var deferred = m.deferred()
-		deferred.promise.then(null, function(data) {return "foo"}).then(null, function(data) {value = data})
+		deferred.promise.then(null, function(data) {return "foo"}).then(function(data) {value = data})
 		deferred.reject("test")
 		return value === "foo"
 	})