Added message sending

lib/Client/Client.js

@@ -23,9 +23,7 @@ var Client = (function (_EventEmitter) {
 		this.internal = new InternalClient(this);
 	}
 
-	/*
- 	def login
- */
+	// def login
 
 	Client.prototype.login = function login(email, password) {
 		var cb = arguments.length <= 2 || arguments[2] === undefined ? function (err, token) {} : arguments[2];
@@ -43,9 +41,104 @@ var Client = (function (_EventEmitter) {
 		});
 	};
 
-	/*
- 	def logout
- */
+	// def logout
+
+	Client.prototype.logout = function logout() {
+		var cb = arguments.length <= 0 || arguments[0] === undefined ? function (err) {} : arguments[0];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			self.internal.logout().then(function () {
+				cb();
+				resolve();
+			})["catch"](function (e) {
+				cb(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.sendMessage = function sendMessage(where, content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+		var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			if (typeof options === "function") {
+				// options is the callback
+				callback = options;
+			}
+
+			self.internal.sendMessage(where, content, options).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.sendTTSMessage = function sendTTSMessage(where, content) {
+		var callback = arguments.length <= 2 || arguments[2] === undefined ? function (e, m) {} : arguments[2];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+			self.sendMessage(where, content, { tts: true }).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
+
+	Client.prototype.reply = function reply(where, content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+		var callback = arguments.length <= 3 || arguments[3] === undefined ? function (e, m) {} : arguments[3];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			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(function (m) {
+					callback(null, m);
+					resolve(m);
+				})["catch"](function (e) {
+					callback(e);
+					reject(e);
+				});
+			} else {
+				var err = new Error("Destination not resolvable to a message!");
+				callback(err);
+				reject(err);
+			}
+		});
+	};
+
+	Client.prototype.replyTTS = function replyTTS(where, content) {
+		var callback = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];
+
+		return new Promise(function (resolve, reject) {
+			self.reply(where, content, { tts: true }).then(function (m) {
+				callback(null, m);
+				resolve(m);
+			})["catch"](function (e) {
+				callback(e);
+				reject(e);
+			});
+		});
+	};
 
 	return Client;
 })(EventEmitter);

lib/Client/InternalClient.js

@@ -12,6 +12,7 @@ var Constants = require("../Constants.js"),
     PacketType = Constants.PacketType;
 
 var Cache = require("../Util/Cache.js");
+var Resolver = require("./Resolver/Resolver.js");
 
 var User = require("../Structures/User.js"),
     Channel = require("../Structures/Channel.js"),
@@ -40,6 +41,7 @@ var InternalClient = (function () {
 		this.channels = new Cache();
 		this.servers = new Cache();
 		this.private_channels = new Cache();
+		this.resolver = new Resolver(this);
 	}
 
 	// def login
@@ -114,6 +116,29 @@ var InternalClient = (function () {
 		});
 	};
 
+	// def startPM
+
+	InternalClient.prototype.startPM = function startPM(resUser) {
+		var self = this;
+		return new Promise(function (resolve, reject) {
+			var user = self.resolver.resolveUser(resUser);
+
+			if (user) {
+
+				// start the PM
+				request.post("" + Endpoints.USER_CHANNELS(user.id)).set("authorization", self.token).end(function (err, res) {
+					if (err) {
+						reject(new Error(err.response.text));
+					} else {
+						resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
+					}
+				});
+			} else {
+				reject(new Error("Unable to resolve resUser to a User"));
+			}
+		});
+	};
+
 	// def getGateway
 
 	InternalClient.prototype.getGateway = function getGateway() {
@@ -126,6 +151,39 @@ var InternalClient = (function () {
 		});
 	};
 
+	// def sendMessage
+
+	InternalClient.prototype.sendMessage = function sendMessage(where, _content) {
+		var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
+
+		var self = this;
+		return new Promise(function (resolve, reject) {
+
+			self.resolver.resolveChannel(where).then(next)["catch"](function (e) {
+				return reject(new Error("Error resolving destination"));
+			});
+
+			function next(destination) {
+				//var destination;
+				var content = self.resolver.resolveString(_content);
+				var mentions = self.resolver.resolveMentions(content);
+
+				request.post(Endpoints.CHANNEL_MESSAGES(destination.id)).set("authorization", self.token).send({
+					content: content,
+					mentions: mentions,
+					tts: options.tts
+				}).end(function (err, res) {
+					if (err) {
+						reject(new Error(err.response.text));
+					} else {
+
+						resolve(destination.messages.add(new Message(res.body, destination, self.client)));
+					}
+				});
+			}
+		});
+	};
+
 	InternalClient.prototype.sendWS = function sendWS(object) {
 		this.websocket.send(JSON.stringify(object));
 	};
@@ -207,7 +265,8 @@ var InternalClient = (function () {
 					// format: https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-format
 					var channel = self.channels.get("id", data.channel_id);
 					if (channel) {
-						channel.messages.add(new Message(data, channel, client));
+						var msg = channel.messages.add(new Message(data, channel, client));
+						client.emit("message", msg);
 					} else {
 						client.emit("warn", "message created but channel is not cached");
 					}

lib/Client/Resolver/Resolver.js

@@ -2,6 +2,149 @@
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var Resolver = function Resolver() {
-	_classCallCheck(this, Resolver);
-};
+var User = require("../../Structures/User.js"),
+    Channel = require("../../Structures/Channel.js"),
+    TextChannel = require("../../Structures/TextChannel.js"),
+    VoiceChannel = require("../../Structures/VoiceChannel.js"),
+    ServerChannel = require("../../Structures/ServerChannel.js"),
+    PMChannel = require("../../Structures/PMChannel.js"),
+    Server = require("../../Structures/Server.js"),
+    Message = require("../../Structures/Message.js");
+
+var Resolver = (function () {
+	function Resolver(client) {
+		_classCallCheck(this, Resolver);
+
+		this.client = client;
+	}
+
+	Resolver.prototype.resolveMentions = function resolveMentions(resource) {
+		// resource is a string
+		var _mentions = [];
+		for (var _iterator = resource.match(/<@[^>]*>/g) || [], _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+			var _ref;
+
+			if (_isArray) {
+				if (_i >= _iterator.length) break;
+				_ref = _iterator[_i++];
+			} else {
+				_i = _iterator.next();
+				if (_i.done) break;
+				_ref = _i.value;
+			}
+
+			var mention = _ref;
+
+			_mentions.push(mention.substring(2, mention.length - 1));
+		}
+		return _mentions;
+	};
+
+	Resolver.prototype.resolveString = function resolveString(resource) {
+
+		// accepts Array, Channel, Server, User, Message, String and anything
+		// toString()-able
+
+		var final = resource;
+		if (resource instanceof Array) {
+			final = resource.join("\n");
+		}
+
+		return final.toString();
+	};
+
+	Resolver.prototype.resolveUser = function resolveUser(resource) {
+		/*
+  	accepts a Message, Channel, Server, String ID, User, PMChannel
+  */
+		var found = null;
+		if (resource instanceof Message) {
+			found = resource.author;
+		} else if (resource instanceof TextChannel) {
+			var lmsg = resource.lastMessage;
+			if (lmsg) {
+				found = lmsg.author;
+			}
+		} else if (resource instanceof Server) {
+			found = resource.owner;
+		} else if (resource instanceof PMChannel) {
+			found = resource.recipient;
+		} else if (resource instanceof String || typeof resource === "string") {
+			found = this.client.internal.users.get("id", resource);
+		}
+
+		return found;
+	};
+
+	Resolver.prototype.resolveMessage = function resolveMessage(resource) {
+		// accepts a Message, PMChannel & TextChannel
+		var found = null;
+
+		if (resource instanceof TextChannel || resource instanceof PMChannel) {
+			found = resource.lastMessage;
+		} else if (resource instanceof Message) {
+			found = resource;
+		}
+
+		return found;
+	};
+
+	Resolver.prototype.resolveChannel = function resolveChannel(resource) {
+		/*
+  	accepts a Message, Channel, Server, String ID, User
+   */
+		var self = this;
+
+		return new Promise(function (resolve, reject) {
+			var found = null;
+			if (resource instanceof Message) {
+				found = resource.channel;
+			} else if (resource instanceof Channel) {
+				found = resource;
+			} else if (resource instanceof Server) {
+				found = resource.channels.get("id", resource.id);
+			} else if (resource instanceof String || typeof resource === "string") {
+				found = self.client.internal.channels.get("id", resource);
+			} else if (resource instanceof User) {
+				// see if a PM exists
+				var chatFound = false;
+				for (var _iterator2 = self.client.internal.private_channels, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+					var _ref2;
+
+					if (_isArray2) {
+						if (_i2 >= _iterator2.length) break;
+						_ref2 = _iterator2[_i2++];
+					} else {
+						_i2 = _iterator2.next();
+						if (_i2.done) break;
+						_ref2 = _i2.value;
+					}
+
+					var pmchat = _ref2;
+
+					if (pmchat.recipient.equals(resource)) {
+						chatFound = pmchat;
+						break;
+					}
+				}
+				if (chatFound) {
+					// a PM already exists!
+					found = chatFound;
+				} else {
+					// PM does not exist :\
+					self.client.internal.startPM(resource).then(function (pmchannel) {
+						return resolve(pmchannel);
+					})["catch"](function (e) {
+						return reject(e);
+					});
+					return;
+				}
+			}
+			if (found) resolve(found);else reject();
+		});
+	};
+
+	return Resolver;
+})();
+
+module.exports = Resolver;

lib/Structures/Message.js

@@ -5,34 +5,41 @@ function _classCallCheck(instance, Constructor) { if (!(instance instanceof Cons
 var Cache = require("../Util/Cache.js");
 var User = require("./User.js");
 
-var Message = function Message(data, channel, client) {
-	var _this = this;
+var Message = (function () {
+	function Message(data, channel, client) {
+		var _this = this;
 
-	_classCallCheck(this, Message);
+		_classCallCheck(this, Message);
 
-	this.channel = channel;
-	this.client = client;
+		this.channel = channel;
+		this.client = client;
 
-	this.nonce = data.nonce;
-	this.attachments = data.attachments;
-	this.tts = data.tts;
-	this.embeds = data.embeds;
-	this.timestamp = Date.parse(data.timestamp);
-	this.everyoneMentioned = data.mention_everyone;
-	this.id = data.id;
+		this.nonce = data.nonce;
+		this.attachments = data.attachments;
+		this.tts = data.tts;
+		this.embeds = data.embeds;
+		this.timestamp = Date.parse(data.timestamp);
+		this.everyoneMentioned = data.mention_everyone;
+		this.id = data.id;
 
-	if (data.edited_timestamp) this.editedTimestamp = Date.parse(data.edited_timestamp);
-	this.author = client.internal.users.add(new User(data.author, client));
-	this.content = data.content;
-	this.mentions = new Cache();
+		if (data.edited_timestamp) this.editedTimestamp = Date.parse(data.edited_timestamp);
+		this.author = client.internal.users.add(new User(data.author, client));
+		this.content = data.content;
+		this.mentions = new Cache();
 
-	data.mentions.forEach(function (mention) {
-		// this is .add and not .get because it allows the bot to cache
-		// users from messages from logs who may have left the server and were
-		// not previously cached.
-		console.log(mention);
-		_this.mentions.add(client.internal.users.add(new User(mention, client)));
-	});
-};
+		data.mentions.forEach(function (mention) {
+			// this is .add and not .get because it allows the bot to cache
+			// users from messages from logs who may have left the server and were
+			// not previously cached.
+			_this.mentions.add(client.internal.users.add(new User(mention, client)));
+		});
+	}
+
+	Message.prototype.toString = function toString() {
+		return this.content;
+	};
+
+	return Message;
+})();
 
 module.exports = Message;

lib/Structures/PMChannel.js

@@ -26,6 +26,10 @@ var PMChannel = (function (_Equality) {
 
 	/* warning! may return null */
 
+	PMChannel.prototype.toString = function toString() {
+		return this.recipient.toString();
+	};
+
 	_createClass(PMChannel, [{
 		key: "lastMessage",
 		get: function get() {

lib/Structures/ServerChannel.js

@@ -17,6 +17,7 @@ var ServerChannel = (function (_Channel) {
 		_classCallCheck(this, ServerChannel);
 
 		_Channel.call(this, data, client);
+		this.name = data.name;
 		this.type = data.type;
 		this.permissionOverwrites = new Cache();
 		data.permission_overwrites.forEach(function (permission) {
@@ -24,6 +25,10 @@ var ServerChannel = (function (_Channel) {
 		});
 	}
 
+	ServerChannel.prototype.toString = function toString() {
+		return this.name;
+	};
+
 	return ServerChannel;
 })(Channel);
 

lib/index.js

@@ -8,6 +8,13 @@ var a = new module.exports.Client();
 a.on("debug", function (m) {
 	return console.log("[debug]", m);
 });
+
+a.on("message", function (m) {
+	if (m.content === "$$$") a.reply(m, "hi man!")["catch"](function (e) {
+		return console.log(e.stack);
+	});
+});
+
 a.login(process.env["discordEmail"], process.env["discordPass"])["catch"](function (e) {
 	return console.log(e);
 });

src/Client/Client.js

@@ -14,12 +14,10 @@ class Client extends EventEmitter{
 		this.internal = new InternalClient(this);
 	}
 	
-	/*
-		def login
-	*/
+	// def login
 	login(email, password, cb=function(err, token){}){
 		var self = this;
-		return new Promise(function(resolve, reject){
+		return new Promise((resolve, reject) => {
 			
 			self.internal.login(email, password)
 				.then((token)=>{
@@ -34,10 +32,101 @@ class Client extends EventEmitter{
 		});
 	}
 	
-	/*
-		def logout
-	*/
+	// 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);
+				})
+			
+		})
+	}
 	
+	sendMessage(where, content, options={}, callback=function(e, m){}){
+		var self = this;
+		return new Promise((resolve, reject) => {
+			
+			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);
+				});
+			
+		});
+	}
+	
+	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);
+				});
+			
+		});
+	}
+	
+	reply(where, content, options={}, callback=function(e,m){}){
+		var self = this;
+		return new Promise((resolve, reject) => {
+			
+			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);
+			}
+			
+		});
+	}
+	
+	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);
+				});
+		});
+	}
 }
 
 module.exports = Client;

src/Client/InternalClient.js

@@ -8,7 +8,7 @@ var ConnectionState = require("./ConnectionState.js");
 var Constants = require("../Constants.js"),
 	Endpoints = Constants.Endpoints,
 	PacketType = Constants.PacketType;
-	
+
 var Cache = require("../Util/Cache.js");
 var Resolver = require("./Resolver/Resolver.js");
 
@@ -88,21 +88,21 @@ class InternalClient {
 	// def logout
 	logout() {
 		var self = this;
-		return new Promise((resolve, reject)=>{
-			
-			if(self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE){
+		return new Promise((resolve, reject) => {
+
+			if (self.state === ConnectionState.DISCONNECTED || self.state === ConnectionState.IDLE) {
 				reject(new Error("Client is not logged in!"));
 				return;
 			}
-			
+
 			request
 				.post(Endpoints.LOGOUT)
 				.set("authorization", self.token)
 				.end((err, res) => {
-					if(err){
+					if (err) {
 						reject(new Error(err.response.text));
-					}else{
-						if(this.websocket){
+					} else {
+						if (this.websocket) {
 							this.websocket.close();
 							this.websocket = null;
 						}
@@ -113,34 +113,34 @@ class InternalClient {
 						resolve();
 					}
 				});
-			
+
 		});
 	}
 	
 	// def startPM
-	startPM(resUser){
+	startPM(resUser) {
 		var self = this;
 		return new Promise((resolve, reject) => {
 			var user = self.resolver.resolveUser(resUser);
-		
-			if(user){
+
+			if (user) {
 				
 				// start the PM
 				request
-					.post(`${Endpoints.USER_CHANNELS(user.id)}`)
+					.post(`${Endpoints.USER_CHANNELS(user.id) }`)
 					.set("authorization", self.token)
 					.end((err, res) => {
-						if(err){
+						if (err) {
 							reject(new Error(err.response.text));
-						}else{
+						} else {
 							resolve(self.private_channels.add(new PMChannel(res.body, self.client)));
 						}
 					});
-				
-			}else{
+
+			} else {
 				reject(new Error("Unable to resolve resUser to a User"));
 			}
-			
+
 		});
 	}
 
@@ -161,6 +161,47 @@ class InternalClient {
 
 		});
 	}
+	
+	// def sendMessage
+	sendMessage(where, _content, options={}) {
+		var self = this;
+		return new Promise((resolve, reject) => {
+
+			self.resolver.resolveChannel(where)
+				.then(next)
+				.catch(e => reject(new Error("Error resolving destination")));
+
+			function next(destination) {
+				//var destination;
+				var content = self.resolver.resolveString(_content);
+				var mentions = self.resolver.resolveMentions(content);
+
+				request
+					.post(Endpoints.CHANNEL_MESSAGES(destination.id))
+					.set("authorization", self.token)
+					.send({
+						content : content,
+						mentions : mentions,
+						tts : options.tts
+					})
+					.end((err, res) => {
+						if (err) {
+							reject(new Error(err.response.text));
+						} else {
+
+							resolve(
+								destination.messages.add(
+									new Message(res.body, destination, self.client)
+									)
+								);
+
+						}
+					});
+
+			}
+
+		});
+	}
 
 	sendWS(object) {
 		this.websocket.send(JSON.stringify(object));
@@ -203,7 +244,7 @@ class InternalClient {
 		this.websocket.onmessage = (e) => {
 
 			if (e.type === "Binary") {
-				if(!zlib) zlib = require("zlib");
+				if (!zlib) zlib = require("zlib");
 				e.data = zlib.inflateSync(e.data).toString();
 			}
 
@@ -230,20 +271,21 @@ class InternalClient {
 						self.private_channels.add(new PMChannel(pm, client));
 					});
 					self.state = ConnectionState.READY;
-					
-					setInterval( ()=> self.sendWS({op : 1, d : Date.now()}), data.heartbeat_interval);
-					
+
+					setInterval(() => self.sendWS({ op: 1, d: Date.now() }), data.heartbeat_interval);
+
 					client.emit("ready");
 					client.emit("debug", `ready packet took ${Date.now() - startTime}ms to process`);
 					client.emit("debug", `ready with ${self.servers.length} servers, ${self.channels.length} channels and ${self.users.length} users cached.`);
 					break;
-				
+
 				case PacketType.MESSAGE_CREATE:
 					// format: https://discordapi.readthedocs.org/en/latest/reference/channels/messages.html#message-format
 					var channel = self.channels.get("id", data.channel_id);
-					if(channel){
-						channel.messages.add( new Message(data, channel, client) );	
-					}else{
+					if (channel) {
+						var msg = channel.messages.add(new Message(data, channel, client));
+						client.emit("message", msg);
+					} else {
 						client.emit("warn", "message created but channel is not cached");
 					}
 					break;

src/Client/Resolver/Resolver.js

@@ -4,6 +4,7 @@ var User = require("../../Structures/User.js"),
 	Channel = require("../../Structures/Channel.js"),
 	TextChannel = require("../../Structures/TextChannel.js"),
 	VoiceChannel = require("../../Structures/VoiceChannel.js"),
+	ServerChannel = require("../../Structures/ServerChannel.js"),
 	PMChannel = require("../../Structures/PMChannel.js"),
 	Server = require("../../Structures/Server.js"),
 	Message = require("../../Structures/Message.js");
@@ -12,26 +13,61 @@ class Resolver {
 	constructor(client) {
 		this.client = client;
 	}
-	
+
+	resolveMentions(resource) {
+		// resource is a string
+		var _mentions = [];
+		for (var mention of (resource.match(/<@[^>]*>/g) || [])) {
+			_mentions.push(mention.substring(2, mention.length - 1));
+		}
+		return _mentions;
+	}
+
+	resolveString(resource) {
+		
+		// accepts Array, Channel, Server, User, Message, String and anything
+		// toString()-able
+		
+		var final = resource;
+		if (resource instanceof Array) {
+			final = resource.join("\n");
+		}
+
+		return final.toString();
+	}
+
 	resolveUser(resource) {
 		/*
 			accepts a Message, Channel, Server, String ID, User, PMChannel
 		*/
 		var found = null;
-		if(resource instanceof Message){
+		if (resource instanceof Message) {
 			found = resource.author;
-		}else if(resource instanceof TextChannel){
+		} else if (resource instanceof TextChannel) {
 			var lmsg = resource.lastMessage;
-			if(lmsg){
+			if (lmsg) {
 				found = lmsg.author;
 			}
-		}else if(resource instanceof Server){
+		} else if (resource instanceof Server) {
 			found = resource.owner;
-		}else if(resource instanceof PMChannel){
+		} else if (resource instanceof PMChannel) {
 			found = resource.recipient;
-		}else if(resource instanceof String || typeof resource === "string"){
+		} else if (resource instanceof String || typeof resource === "string") {
 			found = this.client.internal.users.get("id", resource);
 		}
+
+		return found;
+	}
+	
+	resolveMessage(resource) {
+		// accepts a Message, PMChannel & TextChannel
+		var found = null;
+		
+		if( resource instanceof TextChannel || resource instanceof PMChannel ){
+			found = resource.lastMessage;
+		}else if( resource instanceof Message ){
+			found = resource;
+		}
 		
 		return found;
 	}
@@ -55,24 +91,24 @@ class Resolver {
 			} else if (resource instanceof User) {
 				// see if a PM exists
 				var chatFound = false;
-				for(var pmchat of self.client.internal.private_channels){
-					if(pmchat.recipient.equals(resource)){
+				for (var pmchat of self.client.internal.private_channels) {
+					if (pmchat.recipient.equals(resource)) {
 						chatFound = pmchat;
 						break;
 					}
 				}
-				if(chatFound){
+				if (chatFound) {
 					// a PM already exists!
 					found = chatFound;
-				}else{
+				} else {
 					// PM does not exist :\
 					self.client.internal.startPM(resource)
-						.then( pmchannel => resolve(pmchannel) )
-						.catch( e => reject(e) );
+						.then(pmchannel => resolve(pmchannel))
+						.catch(e => reject(e));
 					return;
 				}
 			}
-			if(found)
+			if (found)
 				resolve(found);
 			else
 				reject();

src/Structures/Message.js

@@ -26,10 +26,13 @@ class Message{
 			// this is .add and not .get because it allows the bot to cache
 			// users from messages from logs who may have left the server and were
 			// not previously cached.
-			console.log(mention);
 			this.mentions.add(client.internal.users.add(new User(mention, client)));
 		});
 	}
+	
+	toString(){
+		return this.content;
+	}
 }
 
 module.exports = Message;

src/Structures/PMChannel.js

@@ -18,6 +18,10 @@ class PMChannel extends Equality{
 	get lastMessage(){
 		return this.messages.get("id", this.lastMessageID);
 	}
+	
+	toString(){
+		return this.recipient.toString();
+	}
 }
 
 module.exports = PMChannel;

src/Structures/ServerChannel.js

@@ -7,12 +7,17 @@ var PermissionOverwrite = require("./PermissionOverwrite.js");
 class ServerChannel extends Channel{
 	constructor(data, client){
 		super(data, client);
+		this.name = data.name;
 		this.type = data.type;
 		this.permissionOverwrites = new Cache();
 		data.permission_overwrites.forEach((permission) => {
 			this.permissionOverwrites.add( new PermissionOverwrite(permission) );
 		});
 	}
+	
+	toString(){
+		return this.name;
+	}
 }
 
 module.exports = ServerChannel;

src/index.js

@@ -4,4 +4,10 @@ module.exports = {
 
 var a = new module.exports.Client();
 a.on("debug", (m) => console.log("[debug]",m));
+
+a.on("message", m => {
+	if(m.content === "$$$")
+		a.reply(m, "hi man!").catch(e => console.log(e.stack));
+});
+
 a.login(process.env["discordEmail"], process.env["discordPass"]).catch((e)=>console.log(e));