From c801dcff2b12a9061e0c4b1a14374d89463cc913 Mon Sep 17 00:00:00 2001
From: Simon Schick <demwizzy@gmail.com>
Date: Tue, 24 Nov 2015 02:48:05 +0100
Subject: [PATCH] fixed rejecting promise invoking callbacks reduces unneeded
 promise wrap fixed cases where the first argument is callback was set despite
 success added missing returns in awaitResponse made defaults arrow functions,
 and commented out their defaults to prevent unsused vars added missing
 returns for status functions

---
 src/Client/Client.js | 950 +++++++++++++------------------------------
 1 file changed, 275 insertions(+), 675 deletions(-)

diff --git a/src/Client/Client.js b/src/Client/Client.js
index 7a7d82399..b4143d723 100644
--- a/src/Client/Client.js
+++ b/src/Client/Client.js
@@ -47,834 +47,434 @@ class Client extends EventEmitter {
 	}
 
 	// def login
-	login(email, password, cb = function (err, token) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.login(email, password)
-				.then((token) => {
-					cb(null, token);
-					resolve(token);
-				})
-				.catch((e) => {
-					cb(e);
-					reject(e);
-				});
-
-		});
+	login(email, password, callback = (/*err, token*/) => {}) {
+		return this.internal.login(email, password)
+		.then((token) => {
+			callback(null, token);
+			return token;
+		}, callback);
 	}
 
 	// def logout
-	logout(cb = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.logout()
-				.then(() => {
-					cb();
-					resolve();
-				})
-				.catch((e) => {
-					cb(e);
-					reject(e);
-				})
-
-		})
+	logout(callback = (/*err*/) => {}) {
+		return this.internal.logout()
+		.then(callback, callback);
 	}
 	// def sendMessage
-	sendMessage(where, content, options = {}, callback = function (e, m) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+	sendMessage(where, content, options = {}, callback = (/*e, m*/) => {}) {
+		if (typeof options === "function") {
+			// options is the callback
+			callback = options;
+		}
 
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
-
-			self.internal.sendMessage(where, content, options)
-				.then(m => {
-					callback(null, m);
-					resolve(m);
-				}).catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+		return this.internal.sendMessage(where, content, options)
+		.then(m => {
+			callback(null, m);
+			return m;
+		}, callback);
 	}
 
 	// def sendTTSMessage
-	sendTTSMessage(where, content, callback = function (e, m) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.sendMessage(where, content, { tts: true })
-				.then(m => {
-					callback(null, m);
-					resolve(m);
-				}).catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	sendTTSMessage(where, content, callback = (/*e, m*/) => {}) {
+		return this.sendMessage(where, content, { tts: true })
+		.then(m => {
+			callback(null, m);
+			return m;
+		}, callback);
 	}
 	// def reply
-	reply(where, content, options = {}, callback = function (e, m) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
+	reply(where, content, options = {}, callback = (/*e, m*/) => {}) {
 
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+		if (typeof options === "function") {
+			// options is the callback
+			callback = options;
+		}
 
-			var msg = self.internal.resolver.resolveMessage(where);
-			if (msg) {
-				content = msg.author + ", " + content;
-				self.internal.sendMessage(msg, content, options)
-					.then(m => {
-						callback(null, m);
-						resolve(m);
-					}).catch(e => {
-						callback(e);
-						reject(e);
-					});
-			} else {
-				var err = new Error("Destination not resolvable to a message!");
-				callback(err);
-				reject(err);
-			}
-
-		});
+		var msg = this.internal.resolver.resolveMessage(where);
+		if (msg) {
+			content = msg.author + ", " + content;
+			return this.internal.sendMessage(msg, content, options)
+			.then(m => {
+				callback(null, m);
+				return m;
+			}, callback);
+		}
+		var err = new Error("Destination not resolvable to a message!");
+		callback(err);
+		return Promise.reject(err);
 	}
 
 	// def replyTTS
-	replyTTS(where, content, callback = function () { }) {
-		return new Promise((resolve, reject) => {
-			self.reply(where, content, { tts: true })
-				.then(m => {
-					callback(null, m);
-					resolve(m);
-				}).catch(e => {
-					callback(e);
-					reject(e);
-				});
-		});
+	replyTTS(where, content, callback = (/**/) => {}) {
+		return this.reply(where, content, { tts: true })
+		.then(m => {
+			callback(null, m);
+			return m;
+		}, callback);
 	}
 	// def deleteMessage
-	deleteMessage(msg, options = {}, callback = function (e) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+	deleteMessage(msg, options = {}, callback = (/*e*/) => {}) {
+		if (typeof options === "function") {
+			// options is the callback
+			callback = options;
+		}
 
-			self.internal.deleteMessage(msg, options)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+		return this.internal.deleteMessage(msg, options)
+		.then(() => {
+			callback(null);
+		}, callback);
 	}
 	//def updateMessage
-	updateMessage(msg, content, options = {}, callback = function (err, msg) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
+	updateMessage(msg, content, options = {}, callback = (/*err, msg*/) => {}) {
+		if (typeof options === "function") {
+			// options is the callback
+			callback = options;
+		}
 
-			self.internal.updateMessage(msg, content, options)
-				.then(msg => {
-					callback(null, msg);
-					resolve(msg);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+		return this.internal.updateMessage(msg, content, options)
+		.then(msg => {
+			callback(null, msg);
+			return msg;
+		}, callback);
 	}
 
 	// def getChannelLogs
-	getChannelLogs(where, limit = 500, options = {}, callback = function (err, logs) { }) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// options is the callback
-				callback = options;
-			}
-			self.internal.getChannelLogs(where, limit, options)
-				.then(logs => {
-					callback(null, logs);
-					resolve(logs);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	getChannelLogs(where, limit = 500, options = {}, callback = (/*err, logs*/) => {}) {
+		if (typeof options === "function") {
+			// options is the callback
+			callback = options;
+		}
 
+		return this.internal.getChannelLogs(where, limit, options)
+		.then(logs => {
+			callback(null, logs);
+			return logs;
+		}, callback);
 	}
 
 	// def getBans
-	getBans(where, callback = function (err, bans) { }) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.getBans(where)
-				.then(bans => {
-					callback(null, bans);
-					resolve(bans);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
-
+	getBans(where, callback = (/*err, bans*/) => {}) {
+		return this.internal.getBans(where)
+		.then(bans => {
+			callback(null, bans);
+			return bans;
+		}, callback);
 	}
 
 	// def sendFile
-	sendFile(where, attachment, name = "image.png", callback = function (err, m) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.sendFile(where, attachment, name)
-				.then(m => {
-					callback(null, m);
-					resolve(m);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	sendFile(where, attachment, name = "image.png", callback = (/*err, m*/) => {}) {
+		this.internal.sendFile(where, attachment, name)
+		.then(m => {
+			callback(null, m);
+			return m;
+		}, callback);
 	}
 
 	// def joinServer
-	joinServer(invite, callback = function (err, srv) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.joinServer(invite)
-				.then(srv => {
-					callback(null, srv);
-					resolve(srv);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-		});
+	joinServer(invite, callback = (/*err, srv*/) => {}) {
+		this.internal.joinServer(invite)
+		.then(srv => {
+			callback(null, srv);
+			return srv;
+		}, callback);
 	}
 
 	// def createServer
-	createServer(name, region = "london", callback = function (err, srv) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.createServer(name, region)
-				.then(srv => {
-					callback(null, srv);
-					resolve(srv);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				})
-		});
+	createServer(name, region = "london", callback = (/*err, srv*/) => {}) {
+		this.internal.createServer(name, region)
+		.then(srv => {
+			callback(null, srv);
+			return srv;
+		}, callback);
 	}
 
 	// def leaveServer
-	leaveServer(server, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.leaveServer(server)
-				.then(() => {
-					callback(); resolve();
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
-
-		});
+	leaveServer(server, callback = (/*err*/) => {}) {
+		return this.internal.leaveServer(server)
+		.then(callback, callback);
 	}
 
 	// def createChannel
-	createChannel(server, name, type = "text", callback = function (err, channel) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof type === "function") {
-				// options is the callback
-				callback = type;
-			}
-			self.internal.createChannel(server, name, type)
-				.then((channel) => {
-					callback(channel); resolve(channel);
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
-
-		});
+	createChannel(server, name, type = "text", callback = (/*err, channel*/) => {}) {
+		if (typeof type === "function") {
+			// options is the callback
+			callback = type;
+		}
+		return this.internal.createChannel(server, name, type)
+		.then((channel) => {
+			callback(channel);
+			return channel;
+		}, callback);
 	}
 
 	// def deleteChannel
-	deleteChannel(channel, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.deleteChannel(channel)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
-
-		});
+	deleteChannel(channel, callback = (/*err*/) => {}) {
+		return this.internal.deleteChannel(channel)
+		.then(callback, callback);
 	}
 
 	//def banMember
-	banMember(user, server, length = 1, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof length === "function") {
-				// length is the callback
-				callback = length;
-			}
-			self.internal.banMember(user, server, length)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
+	banMember(user, server, length = 1, callback = (/*err*/) => {}) {
 
-		});
+		if (typeof length === "function") {
+			// length is the callback
+			callback = length;
+		}
+		return this.internal.banMember(user, server, length)
+		.then(callback, callback);
 	}
 
 	//def unbanMember
-	unbanMember(user, server, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.unbanMember(user, server)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
-
-		});
+	unbanMember(user, server, callback = (/*err*/) => {}) {
+		return this.internal.unbanMember(user, server)
+		.then(callback, callback);
 	}
 
 	//def kickMember
-	kickMember(user, server, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.kickMember(user, server)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e); reject(e);
-				})
-
-		});
+	kickMember(user, server, callback = (/*err*/) => {}) {
+		return this.internal.kickMember(user, server)
+		.then(callback, callback);
 	}
 
 	//def createRole
-	createRole(server, data = null, callback = function (err, res) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof data === "function") {
-				// data is the callback
-				callback = data;
-			}
-			self.internal.createRole(server, data)
-				.then((role) => {
-					callback(null, role);
-					resolve(role);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	createRole(server, data = null, callback = (/*err, res*/) => {}) {
+		if (typeof data === "function") {
+			// data is the callback
+			callback = data;
+		}
+		return this.internal.createRole(server, data)
+		.then((role) => {
+			callback(null, role);
+			return role;
+		}, callback);
 	}
 
 	//def updateRole
-	updateRole(role, data = null, callback = function (err, res) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof data === "function") {
-				// data is the callback
-				callback = data;
-			}
-			self.internal.updateRole(role, data)
-				.then((role) => {
-					callback(null, role);
-					resolve(role);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	updateRole(role, data = null, callback = (/*err, res*/) => {}) {
+		if (typeof data === "function") {
+			// data is the callback
+			callback = data;
+		}
+		return this.internal.updateRole(role, data)
+		.then((role) => {
+			callback(null, role);
+			return role;
+		}, callback);
 	}
 
 	//def deleteRole
-	deleteRole(role, callback = function (err) { }) {
-
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.deleteRole(role)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
-
+	deleteRole(role, callback = (/*err*/) => {}) {
+		return this.internal.deleteRole(role)
+		.then(callback, callback);
 	}
 
 	//def addMemberToRole
-	addMemberToRole(member, role, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.addMemberToRole(member, role)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	addMemberToRole(member, role, callback = (/*err*/) => {}) {
+		return this.internal.addMemberToRole(member, role)
+		.then(callback, callback);
 	}
 
 	// def addUserToRole
-	addUserToRole(member, role, callback = function (err) { }) {
+	addUserToRole(member, role, callback = (/*err*/) => {}) {
 		return this.addMemberToRole(member, role, callback);
 	}
 
 	// def removeMemberFromRole
-	removeMemberFromRole(member, role, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.removeMemberFromRole(member, role)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	removeMemberFromRole(member, role, callback = (/*err*/) => {}) {
+		return this.internal.removeMemberFromRole(member, role)
+		.then(callback, callback);
 	}
 
 	// def removeUserFromRole
-	removeUserFromRole(member, role, callback = function (err) { }) {
+	removeUserFromRole(member, role, callback = (/*err*/) => {}) {
 		return this.removeUserFromRole(member, role, callback);
 	}
 
 	// def createInvite
-	createInvite(chanServ, options, callback = function (err, invite) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof options === "function") {
-				// length is the callback
-				callback = options;
-			}
+	createInvite(chanServ, options, callback = (/*err, invite*/) => {}) {
 
-			self.internal.createInvite(chanServ, options)
-				.then(invite => {
-					callback(null, invite);
-					resolve(invite);
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
+		if (typeof options === "function") {
+			// length is the callback
+			callback = options;
+		}
 
-		});
+		return this.internal.createInvite(chanServ, options)
+		.then(invite => {
+			callback(null, invite);
+		}, callback);
 	}
 
 	// def deleteInvite
-	deleteInvite(invite, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.deleteInvite(invite)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-		});
+	deleteInvite(invite, callback = (/*err*/) => {}) {
+		this.internal.deleteInvite(invite)
+		.then(callback, callback);
 	}
 
 	// def overwritePermissions
-	overwritePermissions(channel, role, options = {}, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.overwritePermissions(channel, role, options)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				})
-
-		});
+	overwritePermissions(channel, role, options = {}, callback = (/*err*/) => {}) {
+		return this.internal.overwritePermissions(channel, role, options)
+		.then(callback, callback);
 	}
 
 	//def setStatus
-	setStatus(idleStatus, gameID, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			if (typeof gameID === "function") {
-				// gameID is the callback
-				callback = gameID;
-			}
-			else if (typeof idleStatus === "function") {
-				// idleStatus is the callback
-				callback = idleStatus;
-			}
+	setStatus(idleStatus, gameID, callback = (/*err*/) => {}) {
 
-			self.internal.setStatus(idleStatus, gameID)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
+		if (typeof gameID === "function") {
+			// gameID is the callback
+			callback = gameID;
+		} else if (typeof idleStatus === "function") {
+			// idleStatus is the callback
+			callback = idleStatus;
+		}
 
-		})
+		return this.internal.setStatus(idleStatus, gameID)
+		.then(callback, callback);
 	}
 
 	//def sendTyping
-	sendTyping(channel, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.sendTyping(channel)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		})
+	sendTyping(channel, callback = (/*err*/) => {}) {
+		return this.internal.sendTyping(channel)
+		.then(callback, callback);
 	}
 
 	// def setTopic
-	setTopic(channel, topic, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setTopic(channel, topic)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		})
+	setTopic(channel, topic, callback = (/*err*/) => {}) {
+		return this.internal.setTopic(channel, topic)
+		.then(callback, callback);
 	}
 
 	//def setChannelName
-	setChannelName(channel, name, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setChannelName(channel, name)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		})
+	setChannelName(channel, name, callback = (/*err*/) => {}) {
+		return this.internal.setChannelName(channel, name)
+		.then(callback, callback);
 	}
 
 	//def setChannelNameAndTopic
-	setChannelNameAndTopic(channel, name, topic, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.setChannelNameAndTopic(channel, name, topic)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		})
+	setChannelNameAndTopic(channel, name, topic, callback = (/*err*/) => {}) {
+		return this.internal.setChannelNameAndTopic(channel, name, topic)
+		.then(callback, callback);
 	}
 
 	//def updateChannel
-	updateChannel(channel, data, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.updateChannel(channel, data)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		})
+	updateChannel(channel, data, callback = (/*err*/) => {}) {
+		return this.internal.updateChannel(channel, data)
+		.then(callback, callback);
 	}
 
 	//def startTyping
-	startTyping(channel, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.startTyping(channel)
-				.then(() => {
-					callback(null);
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	startTyping(channel, callback = (/*err*/) => {}) {
+		return this.internal.startTyping(channel)
+		.then(callback, callback);
 	}
 
 	//def stopTyping
-	stopTyping(channel, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.stopTyping(channel)
-				.then(() => {
-					callback(null);
-					resolve();
-				})
-				.catch(e => {
-					callback(e);
-					reject(e);
-				});
-
-		});
+	stopTyping(channel, callback = (/*err*/) => {}) {
+		return this.internal.stopTyping(channel)
+		.then(callback, callback);
 	}
 
 	//def updateDetails
-	updateDetails(details, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.updateDetails(details)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(err => {
-					callback(err);
-					reject(err);
-				});
-		});
+	updateDetails(details, callback = (/*err*/) => {}) {
+		return this.internal.updateDetails(details)
+		.then(callback, callback);
 	}
 
 	//def setUsername
-	setUsername(name, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.setUsername(name)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(err => {
-					callback(err);
-					reject(err);
-				});
-		});
+	setUsername(name, callback = (/*err*/) => {}) {
+		return this.internal.setUsername(name)
+		.then(callback, callback);
 	}
 
 	//def setAvatar
-	setAvatar(avatar, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.setAvatar(avatar)
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(err => {
-					callback(err);
-					reject(err);
-				});
-		});
+	setAvatar(avatar, callback = (/*err*/) => {}) {
+		return this.internal.setAvatar(avatar)
+		.then(callback, callback);
 	}
 
 	//def joinVoiceChannel
-	joinVoiceChannel(channel, callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-
-			self.internal.joinVoiceChannel(channel)
-				.then(chan => {
-					callback(null, chan);
-					resolve(chan);
-				})
-				.catch(err => {
-					callback(err);
-					reject(err);
-				});
-
-		});
+	joinVoiceChannel(channel, callback = (/*err*/) => {}) {
+		return this.internal.joinVoiceChannel(channel)
+		.then(chan => {
+			callback(null, chan);
+			return chan;
+		}, callback);
 	}
-	
+
 	// def leaveVoiceChannel
-	leaveVoiceChannel(callback = function (err) { }) {
-		var self = this;
-		return new Promise((resolve, reject) => {
-			self.internal.leaveVoiceChannel()
-				.then(() => {
-					callback();
-					resolve();
-				})
-				.catch(err => {
-					callback(err);
-					reject(err);
-				});
-		});
+	leaveVoiceChannel(callback = (/*err*/) => {}) {
+		return this.internal.leaveVoiceChannel()
+		.then(callback, callback);
 	}
-	
+
 	// def awaitResponse
-	awaitResponse(msg, toSend = null, options = null, callback = function (e, newMsg) { }) {
-		
-		var self = this;
-		
-		return new Promise((resolve, reject) => {
+	awaitResponse(msg, toSend = null, options = null, callback = (/*e, newMsg*/) => {}) {
 
-			function error(e) {
-				callback(e);
-				reject(e);
-			}
+		const final = () =>
+			this.internal.awaitResponse(msg)
+			.then(newMsg => {
+				callback(null, newMsg);
+			});
 
-			if (toSend) {
-				if (typeof toSend === "function") {
-					// (msg, callback)
-					callback = toSend;
-					final();
-				} else {
-					// (msg, toSend, ...)
-					if (options) {
-						if (typeof options === "function") {
-							//(msg, toSend, callback)
-							callback = options;
-							this.sendMessage(msg, toSend).then(final).catch(error);
-						} else {
-							//(msg, toSend, options, callback)
-							this.sendMessage(msg, toSend, options).then(final).catch(error);
-						}
-					} else {
-						// (msg, toSend) promise
-						this.sendMessage(msg, toSend).then(final).catch(error);
-					}
-				}
+		var ret;
+
+		if (toSend) {
+			if (typeof toSend === "function") {
+				// (msg, callback)
+				callback = toSend;
 			} else {
-				// (msg) promise
-				final();
+				// (msg, toSend, ...)
+				if (options) {
+					if (typeof options === "function") {
+						//(msg, toSend, callback)
+						callback = options;
+						ret = this.sendMessage(msg, toSend);
+					} else {
+						//(msg, toSend, options, callback)
+						ret = this.sendMessage(msg, toSend, options);
+					}
+				} else {
+					// (msg, toSend) promise
+					ret = this.sendMessage(msg, toSend);
+				}
 			}
+		}
 
-			function final() {
-				self.internal.awaitResponse(msg)
-					.then(newMsg => {
-						resolve(newMsg);
-						callback(null, newMsg);
-					})
-					.catch(error);
-			}
-
-		});
-
+		if (!ret) {
+			ret = Promise.resolve();
+		}
+		// (msg) promise
+		return ret.then(final).catch(callback);
 	}
 
-	setStatusIdle() {
-		this.setStatus("idle");
+	setStatusIdle(callback = (/*err*/) => {}) {
+		return this.internal.setStatus("idle")
+		.then(callback, callback);
 	}
 
-	setStatusOnline(cb = function (err) { }) {
-		this.setStatus("online");
+	setStatusOnline(callback = (/*err*/) => {}) {
+		return this.internal.setStatus("online")
+		.then(callback, callback);
 	}
 
-	setStatusActive() {
-		this.setStatusOnline();
+	setStatusActive(callback) {
+		return this.setStatusOnline(callback);
 	}
 
-	setStatusHere() {
-		this.setStatusOnline();
+	setStatusHere(callback) {
+		return this.setStatusOnline(callback);
 	}
 
-	setStatusAvailable() {
-		this.setStatusOnline();
+	setStatusAvailable(callback) {
+		return this.setStatusOnline(callback);
 	}
 
-	setStatusAway() {
-		this.setStatusIdle();
+	setStatusAway(callback) {
+		return this.setStatusIdle(callback);
 	}
 
 	setPlayingGame(game) {
-		this.setStatus(null, game);
+		return this.setStatus(null, game);
 	}
 }
 
-module.exports = Client;
\ No newline at end of file
+module.exports = Client;