Release v1.0.0

Add UseUserName option (discord) (#234 )
Do not modify username in action (discord)
2025-06-26 13:09:24 +00:00 · 2017-08-05 15:50:21 +02:00 · 2017-08-01 18:18:55 +02:00 · 2017-07-31 21:37:19 +02:00 · 2017-07-30 18:05:27 +02:00 · 2017-07-30 17:48:23 +02:00
106 changed files with 10061 additions and 1420 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,10 +1,17 @@
 language: go
 go:
-    - 1.7.x
+    #- 1.7.x
    - 1.8.x
-    - tip
+      # - tip
+
+# we have everything vendored
 install: true

+env:
+    - GOOS=linux GOARCH=amd64
+      #    - GOOS=windows GOARCH=amd64
+      #- GOOS=linux GOARCH=arm
+
 matrix:
  # It's ok if our code fails on unstable development versions of Go.
  allow_failures:
@ -17,6 +24,7 @@ notifications:
      email: false

 before_script:
+  - MY_VERSION=$(git describe --tags)
  - GO_FILES=$(find . -iname '*.go' | grep -v /vendor/)  # All the .go files, excluding vendor/
  - PKGS=$(go list ./... | grep -v /vendor/)             # All the import paths, excluding vendor/
 #  - go get github.com/golang/lint/golint                 # Linter
@ -25,10 +33,17 @@ before_script:
 # Anything in before_script: that returns a nonzero exit code will
 # flunk the build and immediately stop. It's sorta like having
 # set -e enabled in bash. 
-script:
 script:
  - test -z $(gofmt -s -l $GO_FILES)  # Fail if a .go file hasn't been formatted with gofmt
-  #- go test -v -race $PKGS            # Run all the tests with the race detector enabled
+  - go test -v -race $PKGS            # Run all the tests with the race detector enabled
  - go vet $PKGS                      # go vet is the official Go static analyzer
  - megacheck $PKGS                   # "go vet on steroids" + linter
+  - /bin/bash ci/bintray.sh
  #- golint -set_exit_status $PKGS     # one last linter
+
+deploy:
+  provider: bintray
+  file: ci/deploy.json
+  user: 42wim
+  key:
+     secure: "CeXXe6JOmt7HYR81MdWLua0ltQHhDdkIeRGBFbgd7hkb1wi8eF9DgpAcQrTso8NIlHNZmSAP46uhFgsRvkuezzX0ygalZ7DCJyAyn3sAMEh+UQSHV1WGThRehTtidqRGjetzsIGSwdrJOWil+XTfbO1Z8DGzfakhSuAZka8CM4BAoe3YeP9rYK8h+84x0GHfczvsLtXZ3mWLvQuwe4pK6+ItBCUg0ae7O7ZUpWHy0xQQkkWztY/6RAzXfaG7DuGjIw+20fhx3WOXRNpHCtZ6Bc3qERCpk0s1HhlQWlrN9wDaFTBWYwlvSnNgvxxMbNXJ6RrRJ0l0bA7FUswYwyroxhzrGLdzWDg8dHaQkypocngdalfhpsnoO9j3ApJhomUFJ3UoEq5nOGRUrKn8MPi+dP0zE4kNQ3e4VNa1ufNrvfpWolMg3xh8OXuhQdD5wIM5zFAbRJLqWSCVAjPq4DDPecmvXBOlIial7oa312lN5qnBnUjvAcxszZ+FUyDHT1Grxzna4tMwxY9obPzZUzm7359AOCCwIQFVB8GLqD2nwIstcXS0zGRz+fhviPipHuBa02q5bGUZwmkvrSNab0s8Jo7pCrel2Rz3nWPKaiCfq2WjbW1CLheSMkOQrjsdUd1hhbqNWFPUjJPInTc77NAKCfm5runv5uyowRLh4NNd0sI="
--- a/README-0.6.md
+++ b/README-0.6.md
@ -1,115 +0,0 @@
-# matterbridge
-
-Simple bridge between mattermost, IRC, XMPP, Gitter and Slack
-
-* Relays public channel messages between mattermost, IRC, XMPP, Gitter and Slack. Pick and mix.
-* Supports multiple channels.
-* Matterbridge can also work with private groups on your mattermost.
-
-Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for documentation and an example.
-
-## Changelog
-Since v0.6.1 support for XMPP, Gitter and Slack is added. More details in [changelog.md] (https://github.com/42wim/matterbridge/blob/master/changelog.md)
-
-## Requirements:
-Accounts to one of the supported bridges
-* [Mattermost] (https://github.com/mattermost/platform/)
-* [IRC] (http://www.mirc.com/servers.html)
-* [XMPP] (https://jabber.org)
-* [Gitter] (https://gitter.im)
-* [Slack] (https://www.slack.com)
-
-## binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* For use with mattermost 3.3.0+ [v0.6.1](https://github.com/42wim/matterircd/releases/tag/v0.6.1)
-* For use with mattermost 3.0.0-3.2.0 [v0.5.0](https://github.com/42wim/matterircd/releases/tag/v0.5.0)
-
-
-## Docker
-Create your matterbridge.conf file locally eg in ```/tmp/matterbridge.conf```
-
-```
-docker run -ti -v /tmp/matterbridge.conf:/matterbridge.conf 42wim/matterbridge:0.6.1
-```
-
-## Compatibility
-### Mattermost 
-* Matterbridge v0.6.1 works with mattermost 3.3.0 and higher [3.3.0 release](https://github.com/mattermost/platform/releases/tag/v3.3.0)
-* Matterbridge v0.5.0 works with mattermost 3.0.0 - 3.2.0 [3.2.0 release](https://github.com/mattermost/platform/releases/tag/v3.2.0)
-
-
-#### Webhooks version
-* Configured incoming/outgoing [webhooks](https://www.mattermost.org/webhooks/) on your mattermost instance.
-
-#### Plus (API) version
-* A dedicated user(bot) on your mattermost instance.
-
-
-## building
-Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
-
-```
-cd $GOPATH
-go get github.com/42wim/matterbridge
-```
-
-You should now have matterbridge binary in the bin directory:
-
-```
-$ ls bin/
-matterbridge
-```
-
-## running
-1) Copy the matterbridge.conf.sample to matterbridge.conf in the same directory as the matterbridge binary.  
-2) Edit matterbridge.conf with the settings for your environment. See below for more config information.  
-3) Now you can run matterbridge. 
-
-```
-Usage of ./matterbridge:
-  -conf string
-        config file (default "matterbridge.conf")
-  -debug
-        enable debug
-  -plus
-        running using API instead of webhooks (deprecated, set Plus flag in [general] config)
-  -version
-        show version
-```
-
-## config
-### matterbridge
-matterbridge looks for matterbridge.conf in current directory. (use -conf to specify another file)
-
-Look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for an example.
-
-### mattermost
-#### webhooks version
-You'll have to configure the incoming and outgoing webhooks. 
-
-* incoming webhooks
-Go to "account settings" - integrations - "incoming webhooks".  
-Choose a channel at "Add a new incoming webhook", this will create a webhook URL right below.  
-This URL should be set in the matterbridge.conf in the [mattermost] section (see above)  
-
-* outgoing webhooks
-Go to "account settings" - integrations - "outgoing webhooks".  
-Choose a channel (the same as the one from incoming webhooks) and fill in the address and port of the server matterbridge will run on.  
-
-e.g. http://192.168.1.1:9999 (192.168.1.1:9999 is the BindAddress specified in [mattermost] section of matterbridge.conf)
-
-#### plus version
-You'll have to create a new dedicated user on your mattermost instance.
-Specify the login and password in [mattermost] section of matterbridge.conf
-
-## FAQ
-Please look at [matterbridge.conf.sample] (https://github.com/42wim/matterbridge/blob/master/matterbridge.conf.sample) for more information first. 
-### Mattermost doesn't show the IRC nicks
-If you're running the webhooks version, this can be fixed by either:
-* enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
-
-If you're running the plus version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.conf.
-
-Also look at the ```RemoteNickFormat``` setting.
--- a/README.md
+++ b/README.md
@ -1,7 +1,9 @@
 # matterbridge
 Click on one of the badges below to join the chat   

-[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg)](https://gitter.im/42wim/matterbridge) [![Join the IRC chat at https://webchat.freenode.net/?channels=matterbridgechat](https://img.shields.io/badge/IRC-matterbridgechat-green.svg)](https://webchat.freenode.net/?channels=matterbridgechat) [![Discord](https://img.shields.io/badge/discord-matterbridge-green.svg)](https://discord.gg/AkKPtrQ) [![Matrix](https://img.shields.io/badge/matrix-matterbridge-green.svg)](https://riot.im/app/#/room/#matterbridge:matrix.org) [![Slack](https://img.shields.io/badge/slack-matterbridgechat-green.svg)](https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA)
+[![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg?colorB=42f4242)](https://gitter.im/42wim/matterbridge) [![Join the IRC chat at https://webchat.freenode.net/?channels=matterbridgechat](https://img.shields.io/badge/IRC-matterbridgechat-green.svg?colorB=42f4242)](https://webchat.freenode.net/?channels=matterbridgechat) [![Discord](https://img.shields.io/badge/discord-matterbridge-green.svg?colorB=42f4242)](https://discord.gg/AkKPtrQ) [![Matrix](https://img.shields.io/badge/matrix-matterbridge-green.svg?colorB=42f4242)](https://riot.im/app/#/room/#matterbridge:matrix.org) [![Slack](https://img.shields.io/badge/slack-matterbridgechat-green.svg?colorB=42f4242)](https://join.slack.com/matterbridgechat/shared_invite/MjEwODMxNjU1NDMwLTE0OTk2MTU3NTMtMzZkZmRiNDZhOA) [![Mattermost](https://img.shields.io/badge/mattermost-matterbridge-green.svg?colorB=42f4242)](https://framateam.org/signup_user_complete/?id=tfqm33ggop8x3qgu4boeieta6e) ![Xmpp](https://img.shields.io/badge/xmpp-matterbridge@muc.im.koderoot.net-green.svg?colorB=42f4242)
+
+[![Download stable](https://img.shields.io/github/release/42wim/matterbridge.svg?label=download%20stable)](https://github.com/42wim/matterbridge/releases/latest) [![Download dev](https://img.shields.io/bintray/v/42wim/nightly/Matterbridge.svg?label=download%20dev&colorB=007ec6)](https://bintray.com/42wim/nightly/Matterbridge/_latestVersion)

 ![matterbridge.gif](https://s15.postimg.org/qpjhp6y3f/matterbridge.gif)

@ -11,6 +13,7 @@ Has a REST API.
 # Table of Contents
 * [Features](#features)
 * [Requirements](#requirements)
+ * [Screenshots](https://github.com/42wim/matterbridge/wiki/)
 * [Installing](#installing)
   * [Binaries](#binaries)
   * [Building](#building)
@ -45,13 +48,16 @@ Accounts to one of the supported bridges
 * [Matrix](https://matrix.org)
 * [Steam](https://store.steampowered.com/)

+# Screenshots
+See https://github.com/42wim/matterbridge/wiki
+
 # Installing
 ## Binaries
-Binaries can be found [here] (https://github.com/42wim/matterbridge/releases/)
-* Latest stable release [v0.16.1](https://github.com/42wim/matterbridge/releases/tag/v0.16.1)
+* Latest stable release [v1.0.0](https://github.com/42wim/matterbridge/releases/latest)
+* Development releases (follows master) can be downloaded [here](https://dl.bintray.com/42wim/nightly/)  

 ## Building
-Go 1.6+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)
+Go 1.7+ is required. Make sure you have [Go](https://golang.org/doc/install) properly installed, including setting up your [GOPATH] (https://golang.org/doc/code.html#GOPATH)

 ```
 cd $GOPATH
@ -82,12 +88,12 @@ See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config

 [mattermost]
    [mattermost.work]
-    useAPI=true
    Server="yourmattermostserver.tld"
    Team="yourteam"
    Login="yourlogin"
    Password="yourpass"
    PrefixMessagesWithNick=true
+    RemoteNickFormat="[{PROTOCOL}] <{NICK}> "

 [[gateway]]
 name="mygateway"
@ -105,7 +111,6 @@ enable=true
 ```
 [slack]
 [slack.test]
-useAPI=true
 Token="yourslacktoken"
 PrefixMessagesWithNick=true

@ -131,11 +136,8 @@ RemoteNickFormat="[{PROTOCOL}/{BRIDGE}] <{NICK}> "
 ```

 # Running
-1) Copy the matterbridge.toml.sample to matterbridge.toml 
-2) Edit matterbridge.toml with the settings for your environment. 
-3) Now you can run matterbridge.  (```./matterbridge```)   

-(Matterbridge will only look for the config file in your current directory, if it isn't there specify -conf "/path/toyour/matterbridge.toml")
+See [howto](https://github.com/42wim/matterbridge/wiki/How-to-create-your-config) for a step by step walkthrough for creating your configuration.

 ```
 Usage of ./matterbridge:
@ -160,18 +162,11 @@ See [changelog.md](https://github.com/42wim/matterbridge/blob/master/changelog.m

 # FAQ

-Please look at [matterbridge.toml.sample](https://github.com/42wim/matterbridge/blob/master/matterbridge.toml.sample) for more information first.
-
-## Mattermost doesn't show the IRC nicks
-If you're running the webhooks version, this can be fixed by either:
-* enabling "override usernames". See [mattermost documentation](http://docs.mattermost.com/developer/webhooks-incoming.html#enabling-incoming-webhooks)
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
-
-If you're running the API version you'll need to:
-* setting ```PrefixMessagesWithNick``` to ```true``` in ```mattermost``` section of your matterbridge.toml.
-
-Also look at the ```RemoteNickFormat``` setting.
+See [FAQ](https://github.com/42wim/matterbridge/wiki/FAQ)

+Want to tip ? 
+* eth: 0xb3f9b5387c66ad6be892bcb7bbc67862f3abc16f
+* btc: 1N7cKHj5SfqBHBzDJ6kad4BzeqUBBS2zhs

 # Thanks
 Matterbridge wouldn't exist without these libraries:
--- a/bridge/config/config.go
+++ b/bridge/config/config.go
@ -13,6 +13,7 @@ const (
 	EVENT_JOIN_LEAVE      = "join_leave"
 	EVENT_FAILURE         = "failure"
 	EVENT_REJOIN_CHANNELS = "rejoin_channels"
+	EVENT_USER_ACTION     = "user_action"
 )

 type Message struct {
@ -33,7 +34,6 @@ type ChannelInfo struct {
 	Account     string
 	Direction   string
 	ID          string
-	GID         map[string]bool
 	SameChannel map[string]bool
 	Options     ChannelOptions
 }
@ -77,6 +77,7 @@ type Protocol struct {
 	UseSASL                bool   // IRC
 	UseTLS                 bool   // IRC
 	UseFirstName           bool   // telegram
+	UseUserName            bool   // discord
 	UseInsecureURL         bool   // telegram
 	WebhookBindAddress     string // mattermost, slack
 	WebhookURL             string // mattermost, slack
--- a/bridge/discord/discord.go
+++ b/bridge/discord/discord.go
@ -71,7 +71,7 @@ func (b *bdiscord) Connect() error {
 		flog.Debugf("%#v", err)
 		return err
 	}
-	guilds, err := b.c.UserGuilds()
+	guilds, err := b.c.UserGuilds(100, "", "")
 	if err != nil {
 		flog.Debugf("%#v", err)
 		return err
@ -114,6 +114,9 @@ func (b *bdiscord) Send(msg config.Message) error {
 		flog.Errorf("Could not find channelID for %v", msg.Channel)
 		return nil
 	}
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
+	}
 	if b.Config.WebhookURL == "" {
 		flog.Debugf("Broadcasting using token (API)")
 		b.c.ChannelMessageSend(channelID, msg.Username+msg.Text)
@ -171,11 +174,19 @@ func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 		text = m.ContentWithMentionsReplaced()
 	}

-	channelName := b.getChannelName(m.ChannelID)
+	rmsg := config.Message{Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg",
+		UserID: m.Author.ID}
+
+	rmsg.Channel = b.getChannelName(m.ChannelID)
 	if b.UseChannelID {
-		channelName = "ID:" + m.ChannelID
+		rmsg.Channel = "ID:" + m.ChannelID
+	}
+
+	if !b.Config.UseUserName {
+		rmsg.Username = b.getNick(m.Author)
+	} else {
+		rmsg.Username = m.Author.Username
 	}
-	username := b.getNick(m.Author)

 	if b.Config.ShowEmbeds && m.Message.Embeds != nil {
 		for _, embed := range m.Message.Embeds {
@ -188,10 +199,14 @@ func (b *bdiscord) messageCreate(s *discordgo.Session, m *discordgo.MessageCreat
 		return
 	}

+	text, ok := b.replaceAction(text)
+	if ok {
+		rmsg.Event = config.EVENT_USER_ACTION
+	}
+
+	rmsg.Text = text
 	flog.Debugf("Sending message from %s on %s to gateway", m.Author.Username, b.Account)
-	b.Remote <- config.Message{Username: username, Text: text, Channel: channelName,
-		Account: b.Account, Avatar: "https://cdn.discordapp.com/avatars/" + m.Author.ID + "/" + m.Author.Avatar + ".jpg",
-		UserID: m.Author.ID}
+	b.Remote <- rmsg
 }

 func (b *bdiscord) memberUpdate(s *discordgo.Session, m *discordgo.GuildMemberUpdate) {
@ -283,6 +298,13 @@ func (b *bdiscord) replaceChannelMentions(text string) string {
 	return text
 }

+func (b *bdiscord) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "_") && strings.HasSuffix(text, "_") {
+		return strings.Replace(text, "_", "", -1), true
+	}
+	return text, false
+}
+
 func (b *bdiscord) stripCustomoji(text string) string {
 	// <:doge:302803592035958784>
 	re := regexp.MustCompile("<(:.*?:)[0-9]+>")
--- a/bridge/gitter/gitter.go
+++ b/bridge/gitter/gitter.go
@ -81,8 +81,13 @@ func (b *Bgitter) JoinChannel(channel string) error {
 				// check for ZWSP to see if it's not an echo
 				if !strings.HasSuffix(ev.Message.Text, "") {
 					flog.Debugf("Sending message from %s on %s to gateway", ev.Message.From.Username, b.Account)
-					b.Remote <- config.Message{Username: ev.Message.From.Username, Text: ev.Message.Text, Channel: room,
+					rmsg := config.Message{Username: ev.Message.From.Username, Text: ev.Message.Text, Channel: room,
 						Account: b.Account, Avatar: b.getAvatar(ev.Message.From.Username), UserID: ev.Message.From.ID}
+					if strings.HasPrefix(ev.Message.Text, "@"+ev.Message.From.Username) {
+						rmsg.Event = config.EVENT_USER_ACTION
+						rmsg.Text = strings.Replace(rmsg.Text, "@"+ev.Message.From.Username+" ", "", -1)
+					}
+					b.Remote <- rmsg
 				}
 			case *gitter.GitterConnectionClosed:
 				flog.Errorf("connection with gitter closed for room %s", room)
--- a/bridge/irc/irc.go
+++ b/bridge/irc/irc.go
@ -3,13 +3,13 @@ package birc
 import (
 	"crypto/tls"
 	"fmt"
+	"github.com/42wim/go-ircevent"
 	"github.com/42wim/matterbridge/bridge/config"
 	log "github.com/Sirupsen/logrus"
 	"github.com/paulrosania/go-charset/charset"
 	_ "github.com/paulrosania/go-charset/data"
 	"github.com/saintfish/chardet"
 	ircm "github.com/sorcix/irc"
-	"github.com/thoj/go-ircevent"
 	"io"
 	"io/ioutil"
 	"regexp"
@ -124,9 +124,6 @@ func (b *Birc) JoinChannel(channel string) error {

 func (b *Birc) Send(msg config.Message) error {
 	flog.Debugf("Receiving %#v", msg)
-	if msg.Account == b.Account {
-		return nil
-	}
 	if strings.HasPrefix(msg.Text, "!") {
 		b.Command(&msg)
 	}
@ -138,7 +135,7 @@ func (b *Birc) Send(msg config.Message) error {
 			if len(b.Local) == b.Config.MessageQueue-1 {
 				text = text + " <message clipped>"
 			}
-			b.Local <- config.Message{Text: text, Username: msg.Username, Channel: msg.Channel}
+			b.Local <- config.Message{Text: text, Username: msg.Username, Channel: msg.Channel, Event: msg.Event}
 		} else {
 			flog.Debugf("flooding, dropping message (queue at %d)", len(b.Local))
 		}
@ -151,7 +148,11 @@ func (b *Birc) doSend() {
 	throttle := time.NewTicker(rate)
 	for msg := range b.Local {
 		<-throttle.C
-		b.i.Privmsg(msg.Channel, msg.Username+msg.Text)
+		if msg.Event == config.EVENT_USER_ACTION {
+			b.i.Action(msg.Channel, msg.Username+msg.Text)
+		} else {
+			b.i.Privmsg(msg.Channel, msg.Username+msg.Text)
+		}
 	}
 }

@ -247,10 +248,12 @@ func (b *Birc) handlePrivMsg(event *irc.Event) {
 	if event.Nick == b.Nick {
 		return
 	}
+	rmsg := config.Message{Username: event.Nick, Channel: event.Arguments[0], Account: b.Account, UserID: event.User + "@" + event.Host}
 	flog.Debugf("handlePrivMsg() %s %s %#v", event.Nick, event.Message(), event)
 	msg := ""
 	if event.Code == "CTCP_ACTION" {
-		msg = event.Nick + " "
+		//	msg = event.Nick + " "
+		rmsg.Event = config.EVENT_USER_ACTION
 	}
 	msg += event.Message()
 	// strip IRC colors
@ -279,7 +282,8 @@ func (b *Birc) handlePrivMsg(event *irc.Event) {
 	msg = string(output)

 	flog.Debugf("Sending message from %s on %s to gateway", event.Arguments[0], b.Account)
-	b.Remote <- config.Message{Username: event.Nick, Text: msg, Channel: event.Arguments[0], Account: b.Account, UserID: event.User + "@" + event.Host}
+	rmsg.Text = msg
+	b.Remote <- rmsg
 }

 func (b *Birc) handleTopicWhoTime(event *irc.Event) {
--- a/bridge/matrix/matrix.go
+++ b/bridge/matrix/matrix.go
@ -78,6 +78,11 @@ func (b *Bmatrix) Send(msg config.Message) error {
 	flog.Debugf("Receiving %#v", msg)
 	channel := b.getRoomID(msg.Channel)
 	flog.Debugf("Sending to channel %s", channel)
+	if msg.Event == config.EVENT_USER_ACTION {
+		b.mc.SendMessageEvent(channel, "m.room.message",
+			matrix.TextMessage{"m.emote", msg.Username + msg.Text})
+		return nil
+	}
 	b.mc.SendText(channel, msg.Username+msg.Text)
 	return nil
 }
@ -95,7 +100,7 @@ func (b *Bmatrix) getRoomID(channel string) string {
 func (b *Bmatrix) handlematrix() error {
 	syncer := b.mc.Syncer.(*matrix.DefaultSyncer)
 	syncer.OnEventType("m.room.message", func(ev *matrix.Event) {
-		if ev.Content["msgtype"].(string) == "m.text" && ev.Sender != b.UserID {
+		if (ev.Content["msgtype"].(string) == "m.text" || ev.Content["msgtype"].(string) == "m.emote") && ev.Sender != b.UserID {
 			b.RLock()
 			channel, ok := b.RoomMap[ev.RoomID]
 			b.RUnlock()
@ -108,8 +113,12 @@ func (b *Bmatrix) handlematrix() error {
 				re := regexp.MustCompile("(.*?):.*")
 				username = re.ReplaceAllString(username, `$1`)
 			}
+			rmsg := config.Message{Username: username, Text: ev.Content["body"].(string), Channel: channel, Account: b.Account, UserID: ev.Sender}
+			if ev.Content["msgtype"].(string) == "m.emote" {
+				rmsg.Event = config.EVENT_USER_ACTION
+			}
 			flog.Debugf("Sending message from %s on %s to gateway", ev.Sender, b.Account)
-			b.Remote <- config.Message{Username: username, Text: ev.Content["body"].(string), Channel: channel, Account: b.Account, UserID: ev.Sender}
+			b.Remote <- rmsg
 		}
 		flog.Debugf("Received: %#v", ev)
 	})
--- a/bridge/mattermost/mattermost.go
+++ b/bridge/mattermost/mattermost.go
@ -6,6 +6,7 @@ import (
 	"github.com/42wim/matterbridge/matterclient"
 	"github.com/42wim/matterbridge/matterhook"
 	log "github.com/Sirupsen/logrus"
+	"strings"
 )

 type MMhook struct {
@ -57,6 +58,9 @@ func (b *Bmattermost) Connect() error {
 	if b.Config.WebhookBindAddress != "" {
 		if b.Config.WebhookURL != "" {
 			flog.Info("Connecting using webhookurl (sending) and webhookbindaddress (receiving)")
+			b.mh = matterhook.New(b.Config.WebhookURL,
+				matterhook.Config{InsecureSkipVerify: b.Config.SkipTLSVerify,
+					BindAddress: b.Config.WebhookBindAddress})
 		} else if b.Config.Login != "" {
 			flog.Info("Connecting using login/password (sending)")
 			err := b.apiLogin()
@ -114,6 +118,9 @@ func (b *Bmattermost) JoinChannel(channel string) error {

 func (b *Bmattermost) Send(msg config.Message) error {
 	flog.Debugf("Receiving %#v", msg)
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "*" + msg.Text + "*"
+	}
 	nick := msg.Username
 	message := msg.Text
 	channel := msg.Channel
@ -149,8 +156,14 @@ func (b *Bmattermost) handleMatter() {
 		go b.handleMatterClient(mchan)
 	}
 	for message := range mchan {
+		rmsg := config.Message{Username: message.Username, Channel: message.Channel, Account: b.Account, UserID: message.UserID}
+		text, ok := b.replaceAction(message.Text)
+		if ok {
+			rmsg.Event = config.EVENT_USER_ACTION
+		}
+		rmsg.Text = text
 		flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)
-		b.Remote <- config.Message{Text: message.Text, Username: message.Username, Channel: message.Channel, Account: b.Account, UserID: message.UserID}
+		b.Remote <- rmsg
 	}
 }

@ -171,6 +184,10 @@ func (b *Bmattermost) handleMatterClient(mchan chan *MMMessage) {
 		// only listen to message from our team
 		if (message.Raw.Event == "posted" || message.Raw.Event == "post_edited") &&
 			b.mc.User.Username != message.Username && message.Raw.Data["team_id"].(string) == b.TeamId {
+			// if the message has reactions don't repost it (for now, until we can correlate reaction with message)
+			if message.Post.HasReactions {
+				continue
+			}
 			flog.Debugf("Receiving from matterclient %#v", message)
 			m := &MMMessage{}
 			m.UserID = message.UserID
@ -219,3 +236,10 @@ func (b *Bmattermost) apiLogin() error {
 	go b.mc.StatusLoop()
 	return nil
 }
+
+func (b *Bmattermost) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "*") && strings.HasSuffix(text, "*") {
+		return strings.Replace(text, "*", "", -1), true
+	}
+	return text, false
+}
--- a/bridge/slack/slack.go
+++ b/bridge/slack/slack.go
@ -127,6 +127,9 @@ func (b *Bslack) JoinChannel(channel string) error {

 func (b *Bslack) Send(msg config.Message) error {
 	flog.Debugf("Receiving %#v", msg)
+	if msg.Event == config.EVENT_USER_ACTION {
+		msg.Text = "_" + msg.Text + "_"
+	}
 	nick := msg.Username
 	message := msg.Text
 	channel := msg.Channel
@ -159,6 +162,7 @@ func (b *Bslack) Send(msg config.Message) error {
 	if msg.Avatar != "" {
 		np.IconURL = msg.Avatar
 	}
+	np.Attachments = append(np.Attachments, slack.Attachment{CallbackID: "matterbridge"})
 	b.sc.PostMessage(schannel.ID, message, np)

 	/*
@ -221,12 +225,19 @@ func (b *Bslack) handleSlack() {
 		if b.Config.WebhookURL == "" && b.Config.WebhookBindAddress == "" && message.Username == b.si.User.Name {
 			continue
 		}
+		if message.Text == "" || message.Username == "" {
+			continue
+		}
 		texts := strings.Split(message.Text, "\n")
 		for _, text := range texts {
 			text = b.replaceURL(text)
 			text = html.UnescapeString(text)
 			flog.Debugf("Sending message from %s on %s to gateway", message.Username, b.Account)
-			b.Remote <- config.Message{Text: text, Username: message.Username, Channel: message.Channel, Account: b.Account, Avatar: b.getAvatar(message.Username), UserID: message.UserID}
+			msg := config.Message{Text: text, Username: message.Username, Channel: message.Channel, Account: b.Account, Avatar: b.getAvatar(message.Username), UserID: message.UserID}
+			if message.Raw.SubType == "me_message" {
+				msg.Event = config.EVENT_USER_ACTION
+			}
+			b.Remote <- msg
 		}
 	}
 }
@ -239,7 +250,13 @@ func (b *Bslack) handleSlackClient(mchan chan *MMMessage) {
 			// ignore first message
 			if count > 0 {
 				flog.Debugf("Receiving from slackclient %#v", ev)
-				if !b.Config.EditDisable && ev.SubMessage != nil {
+				if len(ev.Attachments) > 0 {
+					// skip messages we made ourselves
+					if ev.Attachments[0].CallbackID == "matterbridge" {
+						continue
+					}
+				}
+				if !b.Config.EditDisable && ev.SubMessage != nil && ev.SubMessage.ThreadTimestamp != ev.SubMessage.Timestamp {
 					flog.Debugf("SubMessage %#v", ev.SubMessage)
 					ev.User = ev.SubMessage.User
 					ev.Text = ev.SubMessage.Text + b.Config.EditSuffix
@ -249,24 +266,37 @@ func (b *Bslack) handleSlackClient(mchan chan *MMMessage) {
 				if err != nil {
 					continue
 				}
-				user, err := b.rtm.GetUserInfo(ev.User)
-				if err != nil {
-					continue
-				}
 				m := &MMMessage{}
-				m.UserID = user.ID
-				m.Username = user.Name
+				if ev.BotID == "" {
+					user, err := b.rtm.GetUserInfo(ev.User)
+					if err != nil {
+						continue
+					}
+					m.UserID = user.ID
+					m.Username = user.Name
+				}
 				m.Channel = channel.Name
 				m.Text = ev.Text
+				if m.Text == "" {
+					for _, attach := range ev.Attachments {
+						if attach.Text != "" {
+							m.Text = attach.Text
+						} else {
+							m.Text = attach.Fallback
+						}
+					}
+				}
 				m.Raw = ev
 				m.Text = b.replaceMention(m.Text)
-				if ev.BotID != "" && user.Name == "" {
+				// when using webhookURL we can't check if it's our webhook or not for now
+				if ev.BotID != "" && b.Config.WebhookURL == "" {
 					bot, err := b.rtm.GetBotInfo(ev.BotID)
 					if err != nil {
 						continue
 					}
 					if bot.Name != "" {
 						m.Username = bot.Name
+						m.UserID = bot.ID
 					}
 				}
 				mchan <- m
--- a/bridge/telegram/telegram.go
+++ b/bridge/telegram/telegram.go
@ -77,6 +77,7 @@ func (b *Btelegram) Send(msg config.Message) error {

 func (b *Btelegram) handleRecv(updates <-chan tgbotapi.Update) {
 	for update := range updates {
+		flog.Debugf("Receiving from telegram: %#v", update.Message)
 		var message *tgbotapi.Message
 		username := ""
 		channel := ""
--- a/bridge/xmpp/xmpp.go
+++ b/bridge/xmpp/xmpp.go
@ -4,6 +4,7 @@ import (
 	"crypto/tls"
 	"github.com/42wim/matterbridge/bridge/config"
 	log "github.com/Sirupsen/logrus"
+	"github.com/jpillora/backoff"
 	"github.com/mattn/go-xmpp"

 	"strings"
@ -43,7 +44,29 @@ func (b *Bxmpp) Connect() error {
 		return err
 	}
 	flog.Info("Connection succeeded")
-	go b.handleXmpp()
+	go func() {
+		initial := true
+		bf := &backoff.Backoff{
+			Min:    time.Second,
+			Max:    5 * time.Minute,
+			Jitter: true,
+		}
+		for {
+			if initial {
+				b.handleXmpp()
+				initial = false
+			}
+			d := bf.Duration()
+			flog.Infof("Disconnected. Reconnecting in %s", d)
+			time.Sleep(d)
+			b.xc, err = b.createXMPP()
+			if err == nil {
+				b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: "", Account: b.Account, Event: config.EVENT_REJOIN_CHANNELS}
+				b.handleXmpp()
+				bf.Reset()
+			}
+		}
+	}()
 	return nil
 }

@ -96,7 +119,11 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 		for {
 			select {
 			case <-ticker.C:
-				b.xc.PingC2S("", "")
+				flog.Debugf("PING")
+				err := b.xc.PingC2S("", "")
+				if err != nil {
+					flog.Debugf("PING failed %#v", err)
+				}
 			case <-done:
 				return
 			}
@ -106,6 +133,7 @@ func (b *Bxmpp) xmppKeepAlive() chan bool {
 }

 func (b *Bxmpp) handleXmpp() error {
+	var ok bool
 	done := b.xmppKeepAlive()
 	defer close(done)
 	nodelay := time.Time{}
@ -127,8 +155,13 @@ func (b *Bxmpp) handleXmpp() error {
 					nick = s[1]
 				}
 				if nick != b.Config.Nick && v.Stamp == nodelay && v.Text != "" {
+					rmsg := config.Message{Username: nick, Text: v.Text, Channel: channel, Account: b.Account, UserID: v.Remote}
+					rmsg.Text, ok = b.replaceAction(rmsg.Text)
+					if ok {
+						rmsg.Event = config.EVENT_USER_ACTION
+					}
 					flog.Debugf("Sending message from %s on %s to gateway", nick, b.Account)
-					b.Remote <- config.Message{Username: nick, Text: v.Text, Channel: channel, Account: b.Account, UserID: v.Remote}
+					b.Remote <- rmsg
 				}
 			}
 		case xmpp.Presence:
@ -136,3 +169,10 @@ func (b *Bxmpp) handleXmpp() error {
 		}
 	}
 }
+
+func (b *Bxmpp) replaceAction(text string) (string, bool) {
+	if strings.HasPrefix(text, "/me ") {
+		return strings.Replace(text, "/me ", "", -1), true
+	}
+	return text, false
+}
--- a/changelog.md
+++ b/changelog.md
@ -1,3 +1,34 @@
+# v1.0.0
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+* discord: Shows the username instead of the server nickname #234
+
+# v1.0.0-rc1
+## New features
+* general: Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199
+
+## Bugfix
+* general: Handle same account in multiple gateways better
+* mattermost: ignore edited messages with reactions
+* mattermost: Fix double posting of edited messages by using lru cache
+* irc: update vendor
+
+# v0.16.3
+## Bugfix
+* general: Fix in/out logic. Closes #224 
+* general: Fix message modification
+* slack: Disable message from other bots when using webhooks (slack)
+* mattermost: Return better error messages on mattermost connect
+
+# v0.16.2
+## New features
+* general: binary builds against latest commit are now available on https://bintray.com/42wim/nightly/Matterbridge/_latestVersion
+
+## Bugfix
+* slack: fix loop introduced by relaying message of other bots #219
+* slack: Suppress parent message when child message is received #218
+* mattermost: fix regression when using webhookurl and webhookbindaddress #221
+
 # v0.16.1
 ## New features
 * slack: also relay messages of other bots #213
--- a/ci/bintray.sh
+++ b/ci/bintray.sh
@ -0,0 +1,26 @@
+#!/bin/bash
+go version |grep go1.8 || exit
+VERSION=$(git describe --tags)
+mkdir ci/binaries
+GOOS=windows GOARCH=amd64 go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-win64.exe
+GOOS=linux GOARCH=amd64 go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-linux64
+GOOS=linux GOARCH=arm go build -ldflags "-s -w -X main.githash=$(git log --pretty=format:'%h' -n 1)" -o ci/binaries/matterbridge-$VERSION-linux-arm
+cd ci
+cat > deploy.json <<EOF
+{
+    "package": {
+        "name": "Matterbridge",
+        "repo": "nightly",
+        "subject": "42wim"
+    },
+    "version": {
+        "name": "$VERSION"
+    },
+    "files":
+        [
+        {"includePattern": "ci/binaries/(.*)", "uploadPattern":"\$1"}
+        ],
+    "publish": true
+}
+EOF
+
--- a/gateway/gateway.go
+++ b/gateway/gateway.go
@ -5,8 +5,8 @@ import (
 	"github.com/42wim/matterbridge/bridge"
 	"github.com/42wim/matterbridge/bridge/config"
 	log "github.com/Sirupsen/logrus"
-	"github.com/peterhellberg/emojilib"
 	//	"github.com/davecgh/go-spew/spew"
+	"github.com/peterhellberg/emojilib"
 	"regexp"
 	"strings"
 	"time"
@ -14,62 +14,33 @@ import (

 type Gateway struct {
 	*config.Config
-	MyConfig        *config.Gateway
-	Bridges         map[string]*bridge.Bridge
-	Channels        map[string]*config.ChannelInfo
-	ChannelOptions  map[string]config.ChannelOptions
-	Names           map[string]bool
-	Name            string
-	Message         chan config.Message
-	DestChannelFunc func(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo
+	Router         *Router
+	MyConfig       *config.Gateway
+	Bridges        map[string]*bridge.Bridge
+	Channels       map[string]*config.ChannelInfo
+	ChannelOptions map[string]config.ChannelOptions
+	Message        chan config.Message
+	Name           string
 }

-func New(cfg *config.Config) *Gateway {
-	gw := &Gateway{}
-	gw.Config = cfg
-	gw.Channels = make(map[string]*config.ChannelInfo)
-	gw.Message = make(chan config.Message)
-	gw.Bridges = make(map[string]*bridge.Bridge)
-	gw.Names = make(map[string]bool)
-	gw.DestChannelFunc = gw.getDestChannel
+func New(cfg config.Gateway, r *Router) *Gateway {
+	gw := &Gateway{Channels: make(map[string]*config.ChannelInfo), Message: r.Message,
+		Router: r, Bridges: make(map[string]*bridge.Bridge), Config: r.Config}
+	gw.AddConfig(&cfg)
 	return gw
 }

 func (gw *Gateway) AddBridge(cfg *config.Bridge) error {
-	for _, br := range gw.Bridges {
-		if br.Account == cfg.Account {
-			gw.mapChannelsToBridge(br)
-			err := br.JoinChannels()
-			if err != nil {
-				return fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
-			}
-			return nil
-		}
+	br := gw.Router.getBridge(cfg.Account)
+	if br == nil {
+		br = bridge.New(gw.Config, cfg, gw.Message)
 	}
-	log.Infof("Starting bridge: %s ", cfg.Account)
-	br := bridge.New(gw.Config, cfg, gw.Message)
 	gw.mapChannelsToBridge(br)
 	gw.Bridges[cfg.Account] = br
-	err := br.Connect()
-	if err != nil {
-		return fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
-	}
-	err = br.JoinChannels()
-	if err != nil {
-		return fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
-	}
 	return nil
 }

 func (gw *Gateway) AddConfig(cfg *config.Gateway) error {
-	if gw.Names[cfg.Name] {
-		return fmt.Errorf("Gateway with name %s already exists", cfg.Name)
-	}
-	if cfg.Name == "" {
-		return fmt.Errorf("%s", "Gateway without name found")
-	}
-	log.Infof("Starting gateway: %s", cfg.Name)
-	gw.Names[cfg.Name] = true
 	gw.Name = cfg.Name
 	gw.MyConfig = cfg
 	gw.mapChannels()
@ -90,39 +61,6 @@ func (gw *Gateway) mapChannelsToBridge(br *bridge.Bridge) {
 	}
 }

-func (gw *Gateway) Start() error {
-	go gw.handleReceive()
-	return nil
-}
-
-func (gw *Gateway) handleReceive() {
-	for msg := range gw.Message {
-		if msg.Event == config.EVENT_FAILURE {
-			for _, br := range gw.Bridges {
-				if msg.Account == br.Account {
-					go gw.reconnectBridge(br)
-				}
-			}
-		}
-		if msg.Event == config.EVENT_REJOIN_CHANNELS {
-			for _, br := range gw.Bridges {
-				if msg.Account == br.Account {
-					br.Joined = make(map[string]bool)
-					br.JoinChannels()
-				}
-			}
-			continue
-		}
-		if !gw.ignoreMessage(&msg) {
-			msg.Timestamp = time.Now()
-			gw.modifyMessage(&msg)
-			for _, br := range gw.Bridges {
-				gw.handleMessage(msg, br)
-			}
-		}
-	}
-}
-
 func (gw *Gateway) reconnectBridge(br *bridge.Bridge) {
 	br.Disconnect()
 	time.Sleep(time.Second * 5)
@ -138,51 +76,51 @@ RECONNECT:
 	br.JoinChannels()
 }

-func (gw *Gateway) mapChannels() error {
-	for _, br := range append(gw.MyConfig.Out, gw.MyConfig.InOut...) {
+func (gw *Gateway) mapChannelConfig(cfg []config.Bridge, direction string) {
+	for _, br := range cfg {
 		if isApi(br.Account) {
 			br.Channel = "api"
 		}
 		ID := br.Channel + br.Account
-		_, ok := gw.Channels[ID]
-		if !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: "out", ID: ID, Options: br.Options, Account: br.Account,
-				GID: make(map[string]bool), SameChannel: make(map[string]bool)}
-			channel.GID[gw.Name] = true
+		if _, ok := gw.Channels[ID]; !ok {
+			channel := &config.ChannelInfo{Name: br.Channel, Direction: direction, ID: ID, Options: br.Options, Account: br.Account,
+				SameChannel: make(map[string]bool)}
 			channel.SameChannel[gw.Name] = br.SameChannel
 			gw.Channels[channel.ID] = channel
+		} else {
+			// if we already have a key and it's not our current direction it means we have a bidirectional inout
+			if gw.Channels[ID].Direction != direction {
+				gw.Channels[ID].Direction = "inout"
+			}
 		}
-		gw.Channels[ID].GID[gw.Name] = true
 		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
 	}
+}

-	for _, br := range append(gw.MyConfig.In, gw.MyConfig.InOut...) {
-		if isApi(br.Account) {
-			br.Channel = "api"
-		}
-		ID := br.Channel + br.Account
-		_, ok := gw.Channels[ID]
-		if !ok {
-			channel := &config.ChannelInfo{Name: br.Channel, Direction: "in", ID: ID, Options: br.Options, Account: br.Account,
-				GID: make(map[string]bool), SameChannel: make(map[string]bool)}
-			channel.GID[gw.Name] = true
-			channel.SameChannel[gw.Name] = br.SameChannel
-			gw.Channels[channel.ID] = channel
-		}
-		gw.Channels[ID].GID[gw.Name] = true
-		gw.Channels[ID].SameChannel[gw.Name] = br.SameChannel
-	}
+func (gw *Gateway) mapChannels() error {
+	gw.mapChannelConfig(gw.MyConfig.In, "in")
+	gw.mapChannelConfig(gw.MyConfig.Out, "out")
+	gw.mapChannelConfig(gw.MyConfig.InOut, "inout")
 	return nil
 }

 func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []config.ChannelInfo {
 	var channels []config.ChannelInfo
+	// if source channel is in only, do nothing
+	for _, channel := range gw.Channels {
+		// lookup the channel from the message
+		if channel.ID == getChannelID(*msg) {
+			// we only have destinations if the original message is from an "in" (sending) channel
+			if !strings.Contains(channel.Direction, "in") {
+				return channels
+			}
+			continue
+		}
+	}
 	for _, channel := range gw.Channels {
 		if _, ok := gw.Channels[getChannelID(*msg)]; !ok {
 			continue
 		}
-		// add gateway to message
-		gw.validGatewayDest(msg, channel)

 		// do samechannelgateway logic
 		if channel.SameChannel[msg.Gateway] {
@ -191,8 +129,7 @@ func (gw *Gateway) getDestChannel(msg *config.Message, dest bridge.Bridge) []con
 			}
 			continue
 		}
-
-		if channel.Direction == "out" && channel.Account == dest.Account && gw.validGatewayDest(msg, channel) {
+		if strings.Contains(channel.Direction, "out") && channel.Account == dest.Account && gw.validGatewayDest(msg, channel) {
 			channels = append(channels, *channel)
 		}
 	}
@ -211,15 +148,16 @@ func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) {
 	}
 	originchannel := msg.Channel
 	origmsg := msg
-	for _, channel := range gw.DestChannelFunc(&msg, *dest) {
+	channels := gw.getDestChannel(&msg, *dest)
+	for _, channel := range channels {
 		// do not send to ourself
 		if channel.ID == getChannelID(origmsg) {
 			continue
 		}
 		log.Debugf("Sending %#v from %s (%s) to %s (%s)", msg, msg.Account, originchannel, dest.Account, channel.Name)
 		msg.Channel = channel.Name
-		gw.modifyAvatar(&msg, dest)
-		gw.modifyUsername(&msg, dest)
+		msg.Avatar = gw.modifyAvatar(origmsg, dest)
+		msg.Username = gw.modifyUsername(origmsg, dest)
 		// for api we need originchannel as channel
 		if dest.Protocol == "api" {
 			msg.Channel = originchannel
@ -232,6 +170,10 @@ func (gw *Gateway) handleMessage(msg config.Message, dest *bridge.Bridge) {
 }

 func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
+	// if we don't have the bridge, ignore it
+	if _, ok := gw.Bridges[msg.Account]; !ok {
+		return true
+	}
 	if msg.Text == "" {
 		log.Debugf("ignoring empty message %#v from %s", msg, msg.Account)
 		return true
@ -259,7 +201,7 @@ func (gw *Gateway) ignoreMessage(msg *config.Message) bool {
 	return false
 }

-func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
+func (gw *Gateway) modifyUsername(msg config.Message, dest *bridge.Bridge) string {
 	br := gw.Bridges[msg.Account]
 	msg.Protocol = br.Protocol
 	nick := gw.Config.General.RemoteNickFormat
@ -281,10 +223,10 @@ func (gw *Gateway) modifyUsername(msg *config.Message, dest *bridge.Bridge) {
 	nick = strings.Replace(nick, "{NICK}", msg.Username, -1)
 	nick = strings.Replace(nick, "{BRIDGE}", br.Name, -1)
 	nick = strings.Replace(nick, "{PROTOCOL}", br.Protocol, -1)
-	msg.Username = nick
+	return nick
 }

-func (gw *Gateway) modifyAvatar(msg *config.Message, dest *bridge.Bridge) {
+func (gw *Gateway) modifyAvatar(msg config.Message, dest *bridge.Bridge) string {
 	iconurl := gw.Config.General.IconURL
 	if iconurl == "" {
 		iconurl = dest.Config.IconURL
@ -293,11 +235,13 @@ func (gw *Gateway) modifyAvatar(msg *config.Message, dest *bridge.Bridge) {
 	if msg.Avatar == "" {
 		msg.Avatar = iconurl
 	}
+	return msg.Avatar
 }

 func (gw *Gateway) modifyMessage(msg *config.Message) {
 	// replace :emoji: to unicode
 	msg.Text = emojilib.Replace(msg.Text)
+	msg.Gateway = gw.Name
 }

 func getChannelID(msg config.Message) string {
@ -305,35 +249,7 @@ func getChannelID(msg config.Message) string {
 }

 func (gw *Gateway) validGatewayDest(msg *config.Message, channel *config.ChannelInfo) bool {
-	GIDmap := gw.Channels[getChannelID(*msg)].GID
-
-	// gateway is specified in message (probably from api)
-	if msg.Gateway != "" {
-		return channel.GID[msg.Gateway]
-	}
-
-	// check if we are running a samechannelgateway.
-	// if it is and the channel name matches it's ok, otherwise we shouldn't use this channel.
-	for k := range GIDmap {
-		if channel.SameChannel[k] {
-			if msg.Channel == channel.Name {
-				// add the gateway to our message
-				msg.Gateway = k
-				return true
-			} else {
-				return false
-			}
-		}
-	}
-	// check if we are in the correct gateway
-	for k := range GIDmap {
-		if channel.GID[k] {
-			// add the gateway to our message
-			msg.Gateway = k
-			return true
-		}
-	}
-	return false
+	return msg.Gateway == gw.Name
 }

 func isApi(account string) bool {
--- a/gateway/gateway_test.go
+++ b/gateway/gateway_test.go
@ -0,0 +1,288 @@
+package gateway
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/BurntSushi/toml"
+	"github.com/stretchr/testify/assert"
+	"strconv"
+
+	"testing"
+)
+
+var testconfig = `
+[irc.freenode]
+[mattermost.test]
+[gitter.42wim]
+[discord.test]
+[slack.test]
+
+[[gateway]]
+    name = "bridge1"
+    enable=true
+    
+    [[gateway.inout]]
+    account = "irc.freenode"
+    channel = "#wimtesting"
+    
+    [[gateway.inout]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+    #channel="matterbridge/Lobby"
+
+    [[gateway.inout]]
+    account = "discord.test"
+    channel = "general"
+    
+    [[gateway.inout]]
+    account="slack.test"
+    channel="testing"
+	`
+
+var testconfig2 = `
+[irc.freenode]
+[mattermost.test]
+[gitter.42wim]
+[discord.test]
+[slack.test]
+
+[[gateway]]
+    name = "bridge1"
+    enable=true
+    
+    [[gateway.in]]
+    account = "irc.freenode"
+    channel = "#wimtesting"
+    
+    [[gateway.in]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+
+    [[gateway.inout]]
+    account = "discord.test"
+    channel = "general"
+    
+    [[gateway.out]]
+    account="slack.test"
+    channel="testing"
+[[gateway]]
+    name = "bridge2"
+    enable=true
+    
+    [[gateway.in]]
+    account = "irc.freenode"
+    channel = "#wimtesting2"
+    
+    [[gateway.out]]
+    account="gitter.42wim"
+    channel="42wim/testroom"
+
+    [[gateway.out]]
+    account = "discord.test"
+    channel = "general2"
+	`
+var testconfig3 = `
+[irc.zzz]
+[telegram.zzz]
+[slack.zzz]
+[[gateway]]
+name="bridge"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main"		
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="-1111111111111"
+
+    [[gateway.inout]]
+    account="slack.zzz"
+    channel="irc"	
+	
+[[gateway]]
+name="announcements"
+enable=true
+	
+    [[gateway.in]]
+    account="telegram.zzz"
+    channel="-2222222222222"	
+	
+    [[gateway.out]]
+    account="irc.zzz"
+    channel="#main"		
+	
+    [[gateway.out]]
+    account="irc.zzz"
+    channel="#main-help"	
+
+    [[gateway.out]]
+    account="telegram.zzz"
+    channel="--333333333333"	
+
+    [[gateway.out]]
+    account="slack.zzz"
+    channel="general"		
+	
+[[gateway]]
+name="bridge2"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main-help"	
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="--444444444444"	
+
+	
+[[gateway]]
+name="bridge3"
+enable=true
+
+    [[gateway.inout]]
+    account="irc.zzz"
+    channel="#main-telegram"	
+
+    [[gateway.inout]]
+    account="telegram.zzz"
+    channel="--333333333333"
+`
+
+func maketestRouter(input string) *Router {
+	var cfg *config.Config
+	if _, err := toml.Decode(input, &cfg); err != nil {
+		fmt.Println(err)
+	}
+	r, err := NewRouter(cfg)
+	if err != nil {
+		fmt.Println(err)
+	}
+	return r
+}
+func TestNewRouter(t *testing.T) {
+	var cfg *config.Config
+	if _, err := toml.Decode(testconfig, &cfg); err != nil {
+		fmt.Println(err)
+	}
+	r, err := NewRouter(cfg)
+	if err != nil {
+		fmt.Println(err)
+	}
+	assert.Equal(t, 1, len(r.Gateways))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Bridges))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Channels))
+
+	r = maketestRouter(testconfig2)
+	assert.Equal(t, 2, len(r.Gateways))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Bridges))
+	assert.Equal(t, 3, len(r.Gateways["bridge2"].Bridges))
+	assert.Equal(t, 4, len(r.Gateways["bridge1"].Channels))
+	assert.Equal(t, 3, len(r.Gateways["bridge2"].Channels))
+	assert.Equal(t, &config.ChannelInfo{Name: "42wim/testroom", Direction: "out",
+		ID: "42wim/testroomgitter.42wim", Account: "gitter.42wim",
+		SameChannel: map[string]bool{"bridge2": false}},
+		r.Gateways["bridge2"].Channels["42wim/testroomgitter.42wim"])
+	assert.Equal(t, &config.ChannelInfo{Name: "42wim/testroom", Direction: "in",
+		ID: "42wim/testroomgitter.42wim", Account: "gitter.42wim",
+		SameChannel: map[string]bool{"bridge1": false}},
+		r.Gateways["bridge1"].Channels["42wim/testroomgitter.42wim"])
+	assert.Equal(t, &config.ChannelInfo{Name: "general", Direction: "inout",
+		ID: "generaldiscord.test", Account: "discord.test",
+		SameChannel: map[string]bool{"bridge1": false}},
+		r.Gateways["bridge1"].Channels["generaldiscord.test"])
+}
+
+func TestGetDestChannel(t *testing.T) {
+	r := maketestRouter(testconfig2)
+	msg := &config.Message{Text: "test", Channel: "general", Account: "discord.test", Gateway: "bridge1", Protocol: "discord", Username: "test"}
+	for _, br := range r.Gateways["bridge1"].Bridges {
+		switch br.Account {
+		case "discord.test":
+			assert.Equal(t, []config.ChannelInfo{{Name: "general", Account: "discord.test", Direction: "inout", ID: "generaldiscord.test", SameChannel: map[string]bool{"bridge1": false}, Options: config.ChannelOptions{Key: ""}}},
+				r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "slack.test":
+			assert.Equal(t, []config.ChannelInfo{{Name: "testing", Account: "slack.test", Direction: "out", ID: "testingslack.test", SameChannel: map[string]bool{"bridge1": false}, Options: config.ChannelOptions{Key: ""}}},
+				r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "gitter.42wim":
+			assert.Equal(t, []config.ChannelInfo(nil), r.Gateways["bridge1"].getDestChannel(msg, *br))
+		case "irc.freenode":
+			assert.Equal(t, []config.ChannelInfo(nil), r.Gateways["bridge1"].getDestChannel(msg, *br))
+		}
+	}
+}
+
+func TestGetDestChannelAdvanced(t *testing.T) {
+	r := maketestRouter(testconfig3)
+	var msgs []*config.Message
+	i := 0
+	for _, gw := range r.Gateways {
+		for _, channel := range gw.Channels {
+			msgs = append(msgs, &config.Message{Text: "text" + strconv.Itoa(i), Channel: channel.Name, Account: channel.Account, Gateway: gw.Name, Username: "user" + strconv.Itoa(i)})
+			i++
+		}
+	}
+	hits := make(map[string]int)
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			for _, msg := range msgs {
+				channels := gw.getDestChannel(msg, *br)
+				if gw.Name != msg.Gateway {
+					assert.Equal(t, []config.ChannelInfo(nil), channels)
+					continue
+				}
+				switch gw.Name {
+				case "bridge":
+					if (msg.Channel == "#main" || msg.Channel == "-1111111111111" || msg.Channel == "irc") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz" || msg.Account == "slack.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main", Account: "irc.zzz", Direction: "inout", ID: "#mainirc.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "-1111111111111", Account: "telegram.zzz", Direction: "inout", ID: "-1111111111111telegram.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "slack.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "irc", Account: "slack.zzz", Direction: "inout", ID: "ircslack.zzz", SameChannel: map[string]bool{"bridge": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "bridge2":
+					if (msg.Channel == "#main-help" || msg.Channel == "--444444444444") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main-help", Account: "irc.zzz", Direction: "inout", ID: "#main-helpirc.zzz", SameChannel: map[string]bool{"bridge2": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "--444444444444", Account: "telegram.zzz", Direction: "inout", ID: "--444444444444telegram.zzz", SameChannel: map[string]bool{"bridge2": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "bridge3":
+					if (msg.Channel == "#main-telegram" || msg.Channel == "--333333333333") && (msg.Account == "irc.zzz" || msg.Account == "telegram.zzz") {
+						hits[gw.Name]++
+						switch br.Account {
+						case "irc.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "#main-telegram", Account: "irc.zzz", Direction: "inout", ID: "#main-telegramirc.zzz", SameChannel: map[string]bool{"bridge3": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						case "telegram.zzz":
+							assert.Equal(t, []config.ChannelInfo{{Name: "--333333333333", Account: "telegram.zzz", Direction: "inout", ID: "--333333333333telegram.zzz", SameChannel: map[string]bool{"bridge3": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+						}
+					}
+				case "announcements":
+					if msg.Channel != "-2222222222222" && msg.Account != "telegram" {
+						assert.Equal(t, []config.ChannelInfo(nil), channels)
+						continue
+					}
+					hits[gw.Name]++
+					switch br.Account {
+					case "irc.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "#main", Account: "irc.zzz", Direction: "out", ID: "#mainirc.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}, {Name: "#main-help", Account: "irc.zzz", Direction: "out", ID: "#main-helpirc.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					case "slack.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "general", Account: "slack.zzz", Direction: "out", ID: "generalslack.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					case "telegram.zzz":
+						assert.Equal(t, []config.ChannelInfo{{Name: "--333333333333", Account: "telegram.zzz", Direction: "out", ID: "--333333333333telegram.zzz", SameChannel: map[string]bool{"announcements": false}, Options: config.ChannelOptions{Key: ""}}}, channels)
+					}
+				}
+			}
+		}
+	}
+	assert.Equal(t, map[string]int{"bridge3": 4, "bridge": 9, "announcements": 3, "bridge2": 4}, hits)
+}
--- a/gateway/router.go
+++ b/gateway/router.go
@ -0,0 +1,106 @@
+package gateway
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/42wim/matterbridge/gateway/samechannel"
+	log "github.com/Sirupsen/logrus"
+	//	"github.com/davecgh/go-spew/spew"
+	"time"
+)
+
+type Router struct {
+	Gateways map[string]*Gateway
+	Message  chan config.Message
+	*config.Config
+}
+
+func NewRouter(cfg *config.Config) (*Router, error) {
+	r := &Router{}
+	r.Config = cfg
+	r.Message = make(chan config.Message)
+	r.Gateways = make(map[string]*Gateway)
+	sgw := samechannelgateway.New(cfg)
+	gwconfigs := sgw.GetConfig()
+
+	for _, entry := range append(gwconfigs, cfg.Gateway...) {
+		if !entry.Enable {
+			continue
+		}
+		if entry.Name == "" {
+			return nil, fmt.Errorf("%s", "Gateway without name found")
+		}
+		if _, ok := r.Gateways[entry.Name]; ok {
+			return nil, fmt.Errorf("Gateway with name %s already exists", entry.Name)
+		}
+		r.Gateways[entry.Name] = New(entry, r)
+	}
+	return r, nil
+}
+
+func (r *Router) Start() error {
+	m := make(map[string]*bridge.Bridge)
+	for _, gw := range r.Gateways {
+		for _, br := range gw.Bridges {
+			m[br.Account] = br
+		}
+	}
+	for _, br := range m {
+		log.Infof("Starting bridge: %s ", br.Account)
+		err := br.Connect()
+		if err != nil {
+			return fmt.Errorf("Bridge %s failed to start: %v", br.Account, err)
+		}
+		err = br.JoinChannels()
+		if err != nil {
+			return fmt.Errorf("Bridge %s failed to join channel: %v", br.Account, err)
+		}
+	}
+	go r.handleReceive()
+	return nil
+}
+
+func (r *Router) getBridge(account string) *bridge.Bridge {
+	for _, gw := range r.Gateways {
+		if br, ok := gw.Bridges[account]; ok {
+			return br
+		}
+	}
+	return nil
+}
+
+func (r *Router) handleReceive() {
+	for msg := range r.Message {
+		if msg.Event == config.EVENT_FAILURE {
+		Loop:
+			for _, gw := range r.Gateways {
+				for _, br := range gw.Bridges {
+					if msg.Account == br.Account {
+						go gw.reconnectBridge(br)
+						break Loop
+					}
+				}
+			}
+		}
+		if msg.Event == config.EVENT_REJOIN_CHANNELS {
+			for _, gw := range r.Gateways {
+				for _, br := range gw.Bridges {
+					if msg.Account == br.Account {
+						br.Joined = make(map[string]bool)
+						br.JoinChannels()
+					}
+				}
+			}
+		}
+		for _, gw := range r.Gateways {
+			if !gw.ignoreMessage(&msg) {
+				msg.Timestamp = time.Now()
+				gw.modifyMessage(&msg)
+				for _, br := range gw.Bridges {
+					gw.handleMessage(msg, br)
+				}
+			}
+		}
+	}
+}
--- a/gateway/samechannel/samechannel_test.go
+++ b/gateway/samechannel/samechannel_test.go
@ -0,0 +1,31 @@
+package samechannelgateway
+
+import (
+	"fmt"
+	"github.com/42wim/matterbridge/bridge/config"
+	"github.com/BurntSushi/toml"
+	"github.com/stretchr/testify/assert"
+
+	"testing"
+)
+
+var testconfig = `
+[mattermost.test]
+[slack.test]
+
+[[samechannelgateway]]
+   enable = true
+   name = "blah"
+      accounts = [ "mattermost.test","slack.test" ]
+      channels = [ "testing","testing2","testing10"]
+`
+
+func TestGetConfig(t *testing.T) {
+	var cfg *config.Config
+	if _, err := toml.Decode(testconfig, &cfg); err != nil {
+		fmt.Println(err)
+	}
+	sgw := New(cfg)
+	configs := sgw.GetConfig()
+	assert.Equal(t, []config.Gateway{{Name: "blah", Enable: true, In: []config.Bridge(nil), Out: []config.Bridge(nil), InOut: []config.Bridge{{Account: "mattermost.test", Channel: "testing", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "mattermost.test", Channel: "testing2", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "mattermost.test", Channel: "testing10", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing2", Options: config.ChannelOptions{Key: ""}, SameChannel: true}, {Account: "slack.test", Channel: "testing10", Options: config.ChannelOptions{Key: ""}, SameChannel: true}}}}, configs)
+}
--- a/matterbridge.go
+++ b/matterbridge.go
@ -5,14 +5,13 @@ import (
 	"fmt"
 	"github.com/42wim/matterbridge/bridge/config"
 	"github.com/42wim/matterbridge/gateway"
-	"github.com/42wim/matterbridge/gateway/samechannel"
 	log "github.com/Sirupsen/logrus"
 	"github.com/google/gops/agent"
 	"strings"
 )

 var (
-	version = "0.16.1"
+	version = "1.0.0"
 	githash string
 )

@ -43,20 +42,11 @@ func main() {
 		log.Println("WARNING: THIS IS A DEVELOPMENT VERSION. Things may break.")
 	}
 	cfg := config.NewConfig(*flagConfig)
-
-	g := gateway.New(cfg)
-	sgw := samechannelgateway.New(cfg)
-	gwconfigs := sgw.GetConfig()
-	for _, gw := range append(gwconfigs, cfg.Gateway...) {
-		if !gw.Enable {
-			continue
-		}
-		err := g.AddConfig(&gw)
-		if err != nil {
-			log.Fatalf("Starting gateway failed: %s", err)
-		}
+	r, err := gateway.NewRouter(cfg)
+	if err != nil {
+		log.Fatalf("Starting gateway failed: %s", err)
 	}
-	err := g.Start()
+	err = r.Start()
 	if err != nil {
 		log.Fatalf("Starting gateway failed: %s", err)
 	}
--- a/matterbridge.toml.sample
+++ b/matterbridge.toml.sample
@ -443,6 +443,10 @@ Server="yourservername"
 #OPTIONAL (default false)
 ShowEmbeds=false

+#Shows the username (minus the discriminator) instead of the server nickname
+#OPTIONAL (default false)
+UseUserName=false
+
 #Specify WebhookURL. If given, will relay messages using the Webhook, which gives a better look to messages.
 #OPTIONAL (default empty)
 WebhookURL="Yourwebhooktokenhere"
--- a/matterclient/matterclient.go
+++ b/matterclient/matterclient.go
@ -1,6 +1,7 @@
 package matterclient

 import (
+	"crypto/md5"
 	"crypto/tls"
 	"encoding/json"
 	"errors"
@ -16,6 +17,7 @@ import (
 	log "github.com/Sirupsen/logrus"

 	"github.com/gorilla/websocket"
+	"github.com/hashicorp/golang-lru"
 	"github.com/jpillora/backoff"
 	"github.com/mattermost/platform/model"
 )
@ -66,6 +68,7 @@ type MMClient struct {
 	WsPingChan    chan *model.WebSocketResponse
 	ServerVersion string
 	OnWsConnect   func()
+	lruCache      *lru.Cache
 }

 func New(login, pass, team, server string) *MMClient {
@ -73,6 +76,7 @@ func New(login, pass, team, server string) *MMClient {
 	mmclient := &MMClient{Credentials: cred, MessageChan: make(chan *Message, 100), Users: make(map[string]*model.User)}
 	mmclient.log = log.WithFields(log.Fields{"module": "matterclient"})
 	log.SetFormatter(&log.TextFormatter{FullTimestamp: true})
+	mmclient.lruCache, _ = lru.New(500)
 	return mmclient
 }

@ -112,7 +116,10 @@ func (m *MMClient) Login() error {
 	for {
 		d := b.Duration()
 		// bogus call to get the serverversion
-		m.Client.GetClientProperties()
+		_, err := m.Client.GetClientProperties()
+		if err != nil {
+			return fmt.Errorf("%#v", err.Error())
+		}
 		if firstConnection && !supportedVersion(m.Client.ServerVersion) {
 			return fmt.Errorf("unsupported mattermost version: %s", m.Client.ServerVersion)
 		}
@ -267,7 +274,10 @@ func (m *MMClient) WsReceiver() {
 			m.log.Debugf("WsReceiver event: %#v", event)
 			msg := &Message{Raw: &event, Team: m.Credentials.Team}
 			m.parseMessage(msg)
-			m.MessageChan <- msg
+			// check if we didn't empty the message
+			if msg.Text != "" {
+				m.MessageChan <- msg
+			}
 			continue
 		}

@ -303,6 +313,13 @@ func (m *MMClient) parseResponse(rmsg model.WebSocketResponse) {
 }

 func (m *MMClient) parseActionPost(rmsg *Message) {
+	// add post to cache, if it already exists don't relay this again.
+	// this should fix reposts
+	if ok, _ := m.lruCache.ContainsOrAdd(digestString(rmsg.Raw.Data["post"].(string)), true); ok {
+		m.log.Debugf("message %#v in cache, not processing again", rmsg.Raw.Data["post"].(string))
+		rmsg.Text = ""
+		return
+	}
 	data := model.PostFromJson(strings.NewReader(rmsg.Raw.Data["post"].(string)))
 	// we don't have the user, refresh the userlist
 	if m.GetUser(data.UserId) == nil {
@ -857,3 +874,7 @@ func supportedVersion(version string) bool {
 	}
 	return false
 }
+
+func digestString(s string) string {
+	return fmt.Sprintf("%x", md5.Sum([]byte(s)))
+}
--- a/migration.md
+++ b/migration.md
@ -1,50 +0,0 @@
-# Breaking changes from 0.4 to 0.5 for matterbridge (webhooks version)
-## IRC section
-### Server
-Port removed, added to server
-```
-server="irc.freenode.net"
-port=6667
-```
-changed to
-```
-server="irc.freenode.net:6667"
-```
-### Channel
-Removed see Channels section below
-
-### UseSlackCircumfix=true
-Removed, can be done by using ```RemoteNickFormat="<{NICK}> "```
-
-## Mattermost section
-### BindAddress
-Port removed, added to BindAddress
-
-```
-BindAddress="0.0.0.0"
-port=9999
-```
-
-changed to
-
-```
-BindAddress="0.0.0.0:9999"
-```
-
-### Token
-Removed
-
-## Channels section
-```
-[Token "outgoingwebhooktoken1"] 
-IRCChannel="#off-topic"
-MMChannel="off-topic"
-```
-
-changed to
-
-```
-[Channel "channelnameofchoice"] 
-IRC="#off-topic"
-Mattermost="off-topic"
-```
--- a/vendor/github.com/42wim/go-ircevent/LICENSE
+++ b/vendor/github.com/42wim/go-ircevent/LICENSE
--- a/vendor/github.com/42wim/go-ircevent/irc.go
+++ b/vendor/github.com/42wim/go-ircevent/irc.go
@ -87,6 +87,17 @@ func (irc *Connection) readLoop() {
 	}
 }

+// Unescape tag values as defined in the IRCv3.2 message tags spec
+// http://ircv3.net/specs/core/message-tags-3.2.html
+func unescapeTagValue(value string) string {
+	value = strings.Replace(value, "\\:", ";", -1)
+	value = strings.Replace(value, "\\s", " ", -1)
+	value = strings.Replace(value, "\\\\", "\\", -1)
+	value = strings.Replace(value, "\\r", "\r", -1)
+	value = strings.Replace(value, "\\n", "\n", -1)
+	return value
+}
+
 //Parse raw irc messages
 func parseToEvent(msg string) (*Event, error) {
 	msg = strings.TrimSuffix(msg, "\n") //Remove \r\n
@ -95,6 +106,26 @@ func parseToEvent(msg string) (*Event, error) {
 	if len(msg) < 5 {
 		return nil, errors.New("Malformed msg from server")
 	}
+
+	if msg[0] == '@' {
+		// IRCv3 Message Tags
+		if i := strings.Index(msg, " "); i > -1 {
+			event.Tags = make(map[string]string)
+			tags := strings.Split(msg[1:i], ";")
+			for _, data := range tags {
+				parts := strings.SplitN(data, "=", 2)
+				if len(parts) == 1 {
+					event.Tags[parts[0]] = ""
+				} else {
+					event.Tags[parts[0]] = unescapeTagValue(parts[1])
+				}
+			}
+			msg = msg[i+1 : len(msg)]
+		} else {
+			return nil, errors.New("Malformed msg from server")
+		}
+	}
+
 	if msg[0] == ':' {
 		if i := strings.Index(msg, " "); i > -1 {
 			event.Source = msg[1:i]
@ -430,26 +461,84 @@ func (irc *Connection) Connect(server string) error {
 		irc.pwrite <- fmt.Sprintf("PASS %s\r\n", irc.Password)
 	}

-	resChan := make(chan *SASLResult)
+	err = irc.negotiateCaps()
+	if err != nil {
+		return err
+	}
+
+	irc.pwrite <- fmt.Sprintf("NICK %s\r\n", irc.nick)
+	irc.pwrite <- fmt.Sprintf("USER %s 0.0.0.0 0.0.0.0 :%s\r\n", irc.user, irc.user)
+	return nil
+}
+
+// Negotiate IRCv3 capabilities
+func (irc *Connection) negotiateCaps() error {
+	saslResChan := make(chan *SASLResult)
+	if irc.UseSASL {
+		irc.RequestCaps = append(irc.RequestCaps, "sasl")
+		irc.setupSASLCallbacks(saslResChan)
+	}
+
+	if len(irc.RequestCaps) == 0 {
+		return nil
+	}
+
+	cap_chan := make(chan bool, len(irc.RequestCaps))
+	irc.AddCallback("CAP", func(e *Event) {
+		if len(e.Arguments) != 3 {
+			return
+		}
+		command := e.Arguments[1]
+
+		if command == "LS" {
+			missing_caps := len(irc.RequestCaps)
+			for _, cap_name := range strings.Split(e.Arguments[2], " ") {
+				for _, req_cap := range irc.RequestCaps {
+					if cap_name == req_cap {
+						irc.pwrite <- fmt.Sprintf("CAP REQ :%s\r\n", cap_name)
+						missing_caps--
+					}
+				}
+			}
+
+			for i := 0; i < missing_caps; i++ {
+				cap_chan <- true
+			}
+		} else if command == "ACK" || command == "NAK" {
+			for _, cap_name := range strings.Split(strings.TrimSpace(e.Arguments[2]), " ") {
+				if cap_name == "" {
+					continue
+				}
+
+				if command == "ACK" {
+					irc.AcknowledgedCaps = append(irc.AcknowledgedCaps, cap_name)
+				}
+				cap_chan <- true
+			}
+		}
+	})
+
+	irc.pwrite <- "CAP LS\r\n"
+
 	if irc.UseSASL {
-		irc.setupSASLCallbacks(resChan)
-		irc.pwrite <- fmt.Sprintf("CAP LS\r\n")
-		// request SASL
-		irc.pwrite <- fmt.Sprintf("CAP REQ :sasl\r\n")
-		// if sasl request doesn't complete in 15 seconds, close chan and timeout
 		select {
-		case res := <-resChan:
+		case res := <-saslResChan:
 			if res.Failed {
-				close(resChan)
+				close(saslResChan)
 				return res.Err
 			}
 		case <-time.After(time.Second * 15):
-			close(resChan)
+			close(saslResChan)
 			return errors.New("SASL setup timed out. This shouldn't happen.")
 		}
 	}
-	irc.pwrite <- fmt.Sprintf("NICK %s\r\n", irc.nick)
-	irc.pwrite <- fmt.Sprintf("USER %s 0.0.0.0 0.0.0.0 :%s\r\n", irc.user, irc.user)
+
+	// Wait for all capabilities to be ACKed or NAKed before ending negotiation
+	for i := 0; i < len(irc.RequestCaps); i++ {
+		<-cap_chan
+	}
+	irc.pwrite <- fmt.Sprintf("CAP END\r\n")
+
 	return nil
 }

--- a/vendor/github.com/42wim/go-ircevent/irc_callback.go
+++ b/vendor/github.com/42wim/go-ircevent/irc_callback.go
--- a/vendor/github.com/42wim/go-ircevent/irc_sasl.go
+++ b/vendor/github.com/42wim/go-ircevent/irc_sasl.go
@ -43,7 +43,6 @@ func (irc *Connection) setupSASLCallbacks(result chan<- *SASLResult) {
 		result <- &SASLResult{true, errors.New(e.Arguments[1])}
 	})
 	irc.AddCallback("903", func(e *Event) {
-		irc.SendRaw("CAP END")
 		result <- &SASLResult{false, nil}
 	})
 	irc.AddCallback("904", func(e *Event) {
--- a/vendor/github.com/42wim/go-ircevent/irc_struct.go
+++ b/vendor/github.com/42wim/go-ircevent/irc_struct.go
@ -15,20 +15,22 @@ import (
 type Connection struct {
 	sync.Mutex
 	sync.WaitGroup
-	Debug        bool
-	Error        chan error
-	Password     string
-	UseTLS       bool
-	UseSASL      bool
-	SASLLogin    string
-	SASLPassword string
-	SASLMech     string
-	TLSConfig    *tls.Config
-	Version      string
-	Timeout      time.Duration
-	PingFreq     time.Duration
-	KeepAlive    time.Duration
-	Server       string
+	Debug            bool
+	Error            chan error
+	Password         string
+	UseTLS           bool
+	UseSASL          bool
+	RequestCaps      []string
+	AcknowledgedCaps []string
+	SASLLogin        string
+	SASLPassword     string
+	SASLMech         string
+	TLSConfig        *tls.Config
+	Version          string
+	Timeout          time.Duration
+	PingFreq         time.Duration
+	KeepAlive        time.Duration
+	Server           string

 	socket net.Conn
 	pwrite chan string
@ -59,6 +61,7 @@ type Event struct {
 	Source     string //<host>
 	User       string //<usr>
 	Arguments  []string
+	Tags       map[string]string
 	Connection *Connection
 }

--- a/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
+++ b/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
--- a/vendor/github.com/bwmarrin/discordgo/discord.go
+++ b/vendor/github.com/bwmarrin/discordgo/discord.go
@ -13,10 +13,18 @@
 // Package discordgo provides Discord binding for Go
 package discordgo

-import "fmt"
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+)

-// VERSION of Discordgo, follows Symantic Versioning. (http://semver.org/)
-const VERSION = "0.15.0"
+// VERSION of DiscordGo, follows Semantic Versioning. (http://semver.org/)
+const VERSION = "0.16.0"
+
+// ErrMFA will be risen by New when the user has 2FA.
+var ErrMFA = errors.New("account has 2FA enabled")

 // New creates a new Discord session and will automate some startup
 // tasks if given enough information to do so.  Currently you can pass zero
@ -31,6 +39,12 @@ const VERSION = "0.15.0"
 //     With an email, password and auth token - Discord will verify the auth
 //         token, if it is invalid it will sign in with the provided
 //         credentials. This is the Discord recommended way to sign in.
+//
+// NOTE: While email/pass authentication is supported by DiscordGo it is
+// HIGHLY DISCOURAGED by Discord. Please only use email/pass to obtain a token
+// and then use that authentication token for all future connections.
+// Also, doing any form of automation with a user (non Bot) account may result
+// in that account being permanently banned from Discord.
 func New(args ...interface{}) (s *Session, err error) {

 	// Create an empty Session interface.
@ -43,6 +57,8 @@ func New(args ...interface{}) (s *Session, err error) {
 		ShardID:                0,
 		ShardCount:             1,
 		MaxRestRetries:         3,
+		Client:                 &http.Client{Timeout: (20 * time.Second)},
+		sequence:               new(int64),
 	}

 	// If no arguments are passed return the empty Session interface.
@ -60,7 +76,7 @@ func New(args ...interface{}) (s *Session, err error) {

 		case []string:
 			if len(v) > 3 {
-				err = fmt.Errorf("Too many string parameters provided.")
+				err = fmt.Errorf("too many string parameters provided")
 				return
 			}

@ -91,7 +107,7 @@ func New(args ...interface{}) (s *Session, err error) {
 			} else if s.Token == "" {
 				s.Token = v
 			} else {
-				err = fmt.Errorf("Too many string parameters provided.")
+				err = fmt.Errorf("too many string parameters provided")
 				return
 			}

@ -99,7 +115,7 @@ func New(args ...interface{}) (s *Session, err error) {
 			// TODO: Parse configuration struct

 		default:
-			err = fmt.Errorf("Unsupported parameter type provided.")
+			err = fmt.Errorf("unsupported parameter type provided")
 			return
 		}
 	}
@ -113,7 +129,11 @@ func New(args ...interface{}) (s *Session, err error) {
 	} else {
 		err = s.Login(auth, pass)
 		if err != nil || s.Token == "" {
-			err = fmt.Errorf("Unable to fetch discord authentication token. %v", err)
+			if s.MFA {
+				err = ErrMFA
+			} else {
+				err = fmt.Errorf("Unable to fetch discord authentication token. %v", err)
+			}
 			return
 		}
 	}
--- a/vendor/github.com/bwmarrin/discordgo/endpoints.go
+++ b/vendor/github.com/bwmarrin/discordgo/endpoints.go
@ -26,6 +26,13 @@ var (
 	EndpointGateway  = EndpointAPI + "gateway"
 	EndpointWebhooks = EndpointAPI + "webhooks/"

+	EndpointCDN             = "https://cdn.discordapp.com/"
+	EndpointCDNAttachments  = EndpointCDN + "attachments/"
+	EndpointCDNAvatars      = EndpointCDN + "avatars/"
+	EndpointCDNIcons        = EndpointCDN + "icons/"
+	EndpointCDNSplashes     = EndpointCDN + "splashes/"
+	EndpointCDNChannelIcons = EndpointCDN + "channel-icons/"
+
 	EndpointAuth           = EndpointAPI + "auth/"
 	EndpointLogin          = EndpointAuth + "login"
 	EndpointLogout         = EndpointAuth + "logout"
@ -48,7 +55,7 @@ var (
 	EndpointIntegrations = EndpointAPI + "integrations"

 	EndpointUser              = func(uID string) string { return EndpointUsers + uID }
-	EndpointUserAvatar        = func(uID, aID string) string { return EndpointUsers + uID + "/avatars/" + aID + ".jpg" }
+	EndpointUserAvatar        = func(uID, aID string) string { return EndpointCDNAvatars + uID + "/" + aID + ".png" }
 	EndpointUserSettings      = func(uID string) string { return EndpointUsers + uID + "/settings" }
 	EndpointUserGuilds        = func(uID string) string { return EndpointUsers + uID + "/guilds" }
 	EndpointUserGuild         = func(uID, gID string) string { return EndpointUsers + uID + "/guilds/" + gID }
@ -56,6 +63,7 @@ var (
 	EndpointUserChannels      = func(uID string) string { return EndpointUsers + uID + "/channels" }
 	EndpointUserDevices       = func(uID string) string { return EndpointUsers + uID + "/devices" }
 	EndpointUserConnections   = func(uID string) string { return EndpointUsers + uID + "/connections" }
+	EndpointUserNotes         = func(uID string) string { return EndpointUsers + "@me/notes/" + uID }

 	EndpointGuild                = func(gID string) string { return EndpointGuilds + gID }
 	EndpointGuildInivtes         = func(gID string) string { return EndpointGuilds + gID + "/invites" }
@ -73,8 +81,8 @@ var (
 	EndpointGuildInvites         = func(gID string) string { return EndpointGuilds + gID + "/invites" }
 	EndpointGuildEmbed           = func(gID string) string { return EndpointGuilds + gID + "/embed" }
 	EndpointGuildPrune           = func(gID string) string { return EndpointGuilds + gID + "/prune" }
-	EndpointGuildIcon            = func(gID, hash string) string { return EndpointGuilds + gID + "/icons/" + hash + ".jpg" }
-	EndpointGuildSplash          = func(gID, hash string) string { return EndpointGuilds + gID + "/splashes/" + hash + ".jpg" }
+	EndpointGuildIcon            = func(gID, hash string) string { return EndpointCDNIcons + gID + "/" + hash + ".png" }
+	EndpointGuildSplash          = func(gID, hash string) string { return EndpointCDNSplashes + gID + "/" + hash + ".png" }
 	EndpointGuildWebhooks        = func(gID string) string { return EndpointGuilds + gID + "/webhooks" }

 	EndpointChannel                   = func(cID string) string { return EndpointChannels + cID }
@ -89,6 +97,8 @@ var (
 	EndpointChannelMessagesPins       = func(cID string) string { return EndpointChannel(cID) + "/pins" }
 	EndpointChannelMessagePin         = func(cID, mID string) string { return EndpointChannel(cID) + "/pins/" + mID }

+	EndpointGroupIcon = func(cID, hash string) string { return EndpointCDNChannelIcons + cID + "/" + hash + ".png" }
+
 	EndpointChannelWebhooks = func(cID string) string { return EndpointChannel(cID) + "/webhooks" }
 	EndpointWebhook         = func(wID string) string { return EndpointWebhooks + wID }
 	EndpointWebhookToken    = func(wID, token string) string { return EndpointWebhooks + wID + "/" + token }
--- a/vendor/github.com/bwmarrin/discordgo/event.go
+++ b/vendor/github.com/bwmarrin/discordgo/event.go
@ -1,7 +1,5 @@
 package discordgo

-import "fmt"
-
 // EventHandler is an interface for Discord events.
 type EventHandler interface {
 	// Type returns the type of event this handler belongs to.
@ -45,12 +43,15 @@ var registeredInterfaceProviders = map[string]EventInterfaceProvider{}

 // registerInterfaceProvider registers a provider so that DiscordGo can
 // access it's New() method.
-func registerInterfaceProvider(eh EventInterfaceProvider) error {
+func registerInterfaceProvider(eh EventInterfaceProvider) {
 	if _, ok := registeredInterfaceProviders[eh.Type()]; ok {
-		return fmt.Errorf("event %s already registered", eh.Type())
+		return
+		// XXX:
+		// if we should error here, we need to do something with it.
+		// fmt.Errorf("event %s already registered", eh.Type())
 	}
 	registeredInterfaceProviders[eh.Type()] = eh
-	return nil
+	return
 }

 // eventHandlerInstance is a wrapper around an event handler, as functions
@ -210,14 +211,15 @@ func (s *Session) onInterface(i interface{}) {
 		setGuildIds(t.Guild)
 	case *GuildUpdate:
 		setGuildIds(t.Guild)
-	case *Resumed:
-		s.onResumed(t)
 	case *VoiceServerUpdate:
 		go s.onVoiceServerUpdate(t)
 	case *VoiceStateUpdate:
 		go s.onVoiceStateUpdate(t)
 	}
-	s.State.onInterface(s, i)
+	err := s.State.onInterface(s, i)
+	if err != nil {
+		s.log(LogDebug, "error dispatching internal event, %s", err)
+	}
 }

 // onReady handles the ready event.
@ -225,14 +227,4 @@ func (s *Session) onReady(r *Ready) {

 	// Store the SessionID within the Session struct.
 	s.sessionID = r.SessionID
-
-	// Start the heartbeat to keep the connection alive.
-	go s.heartbeat(s.wsConn, s.listening, r.HeartbeatInterval)
-}
-
-// onResumed handles the resumed event.
-func (s *Session) onResumed(r *Resumed) {
-
-	// Start the heartbeat to keep the connection alive.
-	go s.heartbeat(s.wsConn, s.listening, r.HeartbeatInterval)
 }
--- a/vendor/github.com/bwmarrin/discordgo/eventhandlers.go
+++ b/vendor/github.com/bwmarrin/discordgo/eventhandlers.go
@ -7,46 +7,49 @@ package discordgo
 // Event type values are used to match the events returned by Discord.
 // EventTypes surrounded by __ are synthetic and are internal to DiscordGo.
 const (
-	channelCreateEventType           = "CHANNEL_CREATE"
-	channelDeleteEventType           = "CHANNEL_DELETE"
-	channelPinsUpdateEventType       = "CHANNEL_PINS_UPDATE"
-	channelUpdateEventType           = "CHANNEL_UPDATE"
-	connectEventType                 = "__CONNECT__"
-	disconnectEventType              = "__DISCONNECT__"
-	eventEventType                   = "__EVENT__"
-	guildBanAddEventType             = "GUILD_BAN_ADD"
-	guildBanRemoveEventType          = "GUILD_BAN_REMOVE"
-	guildCreateEventType             = "GUILD_CREATE"
-	guildDeleteEventType             = "GUILD_DELETE"
-	guildEmojisUpdateEventType       = "GUILD_EMOJIS_UPDATE"
-	guildIntegrationsUpdateEventType = "GUILD_INTEGRATIONS_UPDATE"
-	guildMemberAddEventType          = "GUILD_MEMBER_ADD"
-	guildMemberRemoveEventType       = "GUILD_MEMBER_REMOVE"
-	guildMemberUpdateEventType       = "GUILD_MEMBER_UPDATE"
-	guildMembersChunkEventType       = "GUILD_MEMBERS_CHUNK"
-	guildRoleCreateEventType         = "GUILD_ROLE_CREATE"
-	guildRoleDeleteEventType         = "GUILD_ROLE_DELETE"
-	guildRoleUpdateEventType         = "GUILD_ROLE_UPDATE"
-	guildUpdateEventType             = "GUILD_UPDATE"
-	messageAckEventType              = "MESSAGE_ACK"
-	messageCreateEventType           = "MESSAGE_CREATE"
-	messageDeleteEventType           = "MESSAGE_DELETE"
-	messageReactionAddEventType      = "MESSAGE_REACTION_ADD"
-	messageReactionRemoveEventType   = "MESSAGE_REACTION_REMOVE"
-	messageUpdateEventType           = "MESSAGE_UPDATE"
-	presenceUpdateEventType          = "PRESENCE_UPDATE"
-	presencesReplaceEventType        = "PRESENCES_REPLACE"
-	rateLimitEventType               = "__RATE_LIMIT__"
-	readyEventType                   = "READY"
-	relationshipAddEventType         = "RELATIONSHIP_ADD"
-	relationshipRemoveEventType      = "RELATIONSHIP_REMOVE"
-	resumedEventType                 = "RESUMED"
-	typingStartEventType             = "TYPING_START"
-	userGuildSettingsUpdateEventType = "USER_GUILD_SETTINGS_UPDATE"
-	userSettingsUpdateEventType      = "USER_SETTINGS_UPDATE"
-	userUpdateEventType              = "USER_UPDATE"
-	voiceServerUpdateEventType       = "VOICE_SERVER_UPDATE"
-	voiceStateUpdateEventType        = "VOICE_STATE_UPDATE"
+	channelCreateEventType            = "CHANNEL_CREATE"
+	channelDeleteEventType            = "CHANNEL_DELETE"
+	channelPinsUpdateEventType        = "CHANNEL_PINS_UPDATE"
+	channelUpdateEventType            = "CHANNEL_UPDATE"
+	connectEventType                  = "__CONNECT__"
+	disconnectEventType               = "__DISCONNECT__"
+	eventEventType                    = "__EVENT__"
+	guildBanAddEventType              = "GUILD_BAN_ADD"
+	guildBanRemoveEventType           = "GUILD_BAN_REMOVE"
+	guildCreateEventType              = "GUILD_CREATE"
+	guildDeleteEventType              = "GUILD_DELETE"
+	guildEmojisUpdateEventType        = "GUILD_EMOJIS_UPDATE"
+	guildIntegrationsUpdateEventType  = "GUILD_INTEGRATIONS_UPDATE"
+	guildMemberAddEventType           = "GUILD_MEMBER_ADD"
+	guildMemberRemoveEventType        = "GUILD_MEMBER_REMOVE"
+	guildMemberUpdateEventType        = "GUILD_MEMBER_UPDATE"
+	guildMembersChunkEventType        = "GUILD_MEMBERS_CHUNK"
+	guildRoleCreateEventType          = "GUILD_ROLE_CREATE"
+	guildRoleDeleteEventType          = "GUILD_ROLE_DELETE"
+	guildRoleUpdateEventType          = "GUILD_ROLE_UPDATE"
+	guildUpdateEventType              = "GUILD_UPDATE"
+	messageAckEventType               = "MESSAGE_ACK"
+	messageCreateEventType            = "MESSAGE_CREATE"
+	messageDeleteEventType            = "MESSAGE_DELETE"
+	messageDeleteBulkEventType        = "MESSAGE_DELETE_BULK"
+	messageReactionAddEventType       = "MESSAGE_REACTION_ADD"
+	messageReactionRemoveEventType    = "MESSAGE_REACTION_REMOVE"
+	messageReactionRemoveAllEventType = "MESSAGE_REACTION_REMOVE_ALL"
+	messageUpdateEventType            = "MESSAGE_UPDATE"
+	presenceUpdateEventType           = "PRESENCE_UPDATE"
+	presencesReplaceEventType         = "PRESENCES_REPLACE"
+	rateLimitEventType                = "__RATE_LIMIT__"
+	readyEventType                    = "READY"
+	relationshipAddEventType          = "RELATIONSHIP_ADD"
+	relationshipRemoveEventType       = "RELATIONSHIP_REMOVE"
+	resumedEventType                  = "RESUMED"
+	typingStartEventType              = "TYPING_START"
+	userGuildSettingsUpdateEventType  = "USER_GUILD_SETTINGS_UPDATE"
+	userNoteUpdateEventType           = "USER_NOTE_UPDATE"
+	userSettingsUpdateEventType       = "USER_SETTINGS_UPDATE"
+	userUpdateEventType               = "USER_UPDATE"
+	voiceServerUpdateEventType        = "VOICE_SERVER_UPDATE"
+	voiceStateUpdateEventType         = "VOICE_STATE_UPDATE"
 )

 // channelCreateEventHandler is an event handler for ChannelCreate events.
@ -137,11 +140,6 @@ func (eh connectEventHandler) Type() string {
 	return connectEventType
 }

-// New returns a new instance of Connect.
-func (eh connectEventHandler) New() interface{} {
-	return &Connect{}
-}
-
 // Handle is the handler for Connect events.
 func (eh connectEventHandler) Handle(s *Session, i interface{}) {
 	if t, ok := i.(*Connect); ok {
@ -157,11 +155,6 @@ func (eh disconnectEventHandler) Type() string {
 	return disconnectEventType
 }

-// New returns a new instance of Disconnect.
-func (eh disconnectEventHandler) New() interface{} {
-	return &Disconnect{}
-}
-
 // Handle is the handler for Disconnect events.
 func (eh disconnectEventHandler) Handle(s *Session, i interface{}) {
 	if t, ok := i.(*Disconnect); ok {
@ -177,11 +170,6 @@ func (eh eventEventHandler) Type() string {
 	return eventEventType
 }

-// New returns a new instance of Event.
-func (eh eventEventHandler) New() interface{} {
-	return &Event{}
-}
-
 // Handle is the handler for Event events.
 func (eh eventEventHandler) Handle(s *Session, i interface{}) {
 	if t, ok := i.(*Event); ok {
@ -529,6 +517,26 @@ func (eh messageDeleteEventHandler) Handle(s *Session, i interface{}) {
 	}
 }

+// messageDeleteBulkEventHandler is an event handler for MessageDeleteBulk events.
+type messageDeleteBulkEventHandler func(*Session, *MessageDeleteBulk)
+
+// Type returns the event type for MessageDeleteBulk events.
+func (eh messageDeleteBulkEventHandler) Type() string {
+	return messageDeleteBulkEventType
+}
+
+// New returns a new instance of MessageDeleteBulk.
+func (eh messageDeleteBulkEventHandler) New() interface{} {
+	return &MessageDeleteBulk{}
+}
+
+// Handle is the handler for MessageDeleteBulk events.
+func (eh messageDeleteBulkEventHandler) Handle(s *Session, i interface{}) {
+	if t, ok := i.(*MessageDeleteBulk); ok {
+		eh(s, t)
+	}
+}
+
 // messageReactionAddEventHandler is an event handler for MessageReactionAdd events.
 type messageReactionAddEventHandler func(*Session, *MessageReactionAdd)

@ -569,6 +577,26 @@ func (eh messageReactionRemoveEventHandler) Handle(s *Session, i interface{}) {
 	}
 }

+// messageReactionRemoveAllEventHandler is an event handler for MessageReactionRemoveAll events.
+type messageReactionRemoveAllEventHandler func(*Session, *MessageReactionRemoveAll)
+
+// Type returns the event type for MessageReactionRemoveAll events.
+func (eh messageReactionRemoveAllEventHandler) Type() string {
+	return messageReactionRemoveAllEventType
+}
+
+// New returns a new instance of MessageReactionRemoveAll.
+func (eh messageReactionRemoveAllEventHandler) New() interface{} {
+	return &MessageReactionRemoveAll{}
+}
+
+// Handle is the handler for MessageReactionRemoveAll events.
+func (eh messageReactionRemoveAllEventHandler) Handle(s *Session, i interface{}) {
+	if t, ok := i.(*MessageReactionRemoveAll); ok {
+		eh(s, t)
+	}
+}
+
 // messageUpdateEventHandler is an event handler for MessageUpdate events.
 type messageUpdateEventHandler func(*Session, *MessageUpdate)

@ -637,11 +665,6 @@ func (eh rateLimitEventHandler) Type() string {
 	return rateLimitEventType
 }

-// New returns a new instance of RateLimit.
-func (eh rateLimitEventHandler) New() interface{} {
-	return &RateLimit{}
-}
-
 // Handle is the handler for RateLimit events.
 func (eh rateLimitEventHandler) Handle(s *Session, i interface{}) {
 	if t, ok := i.(*RateLimit); ok {
@ -769,6 +792,26 @@ func (eh userGuildSettingsUpdateEventHandler) Handle(s *Session, i interface{})
 	}
 }

+// userNoteUpdateEventHandler is an event handler for UserNoteUpdate events.
+type userNoteUpdateEventHandler func(*Session, *UserNoteUpdate)
+
+// Type returns the event type for UserNoteUpdate events.
+func (eh userNoteUpdateEventHandler) Type() string {
+	return userNoteUpdateEventType
+}
+
+// New returns a new instance of UserNoteUpdate.
+func (eh userNoteUpdateEventHandler) New() interface{} {
+	return &UserNoteUpdate{}
+}
+
+// Handle is the handler for UserNoteUpdate events.
+func (eh userNoteUpdateEventHandler) Handle(s *Session, i interface{}) {
+	if t, ok := i.(*UserNoteUpdate); ok {
+		eh(s, t)
+	}
+}
+
 // userSettingsUpdateEventHandler is an event handler for UserSettingsUpdate events.
 type userSettingsUpdateEventHandler func(*Session, *UserSettingsUpdate)

@ -901,10 +944,14 @@ func handlerForInterface(handler interface{}) EventHandler {
 		return messageCreateEventHandler(v)
 	case func(*Session, *MessageDelete):
 		return messageDeleteEventHandler(v)
+	case func(*Session, *MessageDeleteBulk):
+		return messageDeleteBulkEventHandler(v)
 	case func(*Session, *MessageReactionAdd):
 		return messageReactionAddEventHandler(v)
 	case func(*Session, *MessageReactionRemove):
 		return messageReactionRemoveEventHandler(v)
+	case func(*Session, *MessageReactionRemoveAll):
+		return messageReactionRemoveAllEventHandler(v)
 	case func(*Session, *MessageUpdate):
 		return messageUpdateEventHandler(v)
 	case func(*Session, *PresenceUpdate):
@ -925,6 +972,8 @@ func handlerForInterface(handler interface{}) EventHandler {
 		return typingStartEventHandler(v)
 	case func(*Session, *UserGuildSettingsUpdate):
 		return userGuildSettingsUpdateEventHandler(v)
+	case func(*Session, *UserNoteUpdate):
+		return userNoteUpdateEventHandler(v)
 	case func(*Session, *UserSettingsUpdate):
 		return userSettingsUpdateEventHandler(v)
 	case func(*Session, *UserUpdate):
@ -937,6 +986,7 @@ func handlerForInterface(handler interface{}) EventHandler {

 	return nil
 }
+
 func init() {
 	registerInterfaceProvider(channelCreateEventHandler(nil))
 	registerInterfaceProvider(channelDeleteEventHandler(nil))
@ -959,8 +1009,10 @@ func init() {
 	registerInterfaceProvider(messageAckEventHandler(nil))
 	registerInterfaceProvider(messageCreateEventHandler(nil))
 	registerInterfaceProvider(messageDeleteEventHandler(nil))
+	registerInterfaceProvider(messageDeleteBulkEventHandler(nil))
 	registerInterfaceProvider(messageReactionAddEventHandler(nil))
 	registerInterfaceProvider(messageReactionRemoveEventHandler(nil))
+	registerInterfaceProvider(messageReactionRemoveAllEventHandler(nil))
 	registerInterfaceProvider(messageUpdateEventHandler(nil))
 	registerInterfaceProvider(presenceUpdateEventHandler(nil))
 	registerInterfaceProvider(presencesReplaceEventHandler(nil))
@ -970,6 +1022,7 @@ func init() {
 	registerInterfaceProvider(resumedEventHandler(nil))
 	registerInterfaceProvider(typingStartEventHandler(nil))
 	registerInterfaceProvider(userGuildSettingsUpdateEventHandler(nil))
+	registerInterfaceProvider(userNoteUpdateEventHandler(nil))
 	registerInterfaceProvider(userSettingsUpdateEventHandler(nil))
 	registerInterfaceProvider(userUpdateEventHandler(nil))
 	registerInterfaceProvider(voiceServerUpdateEventHandler(nil))
--- a/vendor/github.com/bwmarrin/discordgo/events.go
+++ b/vendor/github.com/bwmarrin/discordgo/events.go
@ -2,7 +2,6 @@ package discordgo

 import (
 	"encoding/json"
-	"time"
 )

 // This file contains all the possible structs that can be
@ -28,7 +27,7 @@ type RateLimit struct {
 // Event provides a basic initial struct for all websocket events.
 type Event struct {
 	Operation int             `json:"op"`
-	Sequence  int             `json:"s"`
+	Sequence  int64           `json:"s"`
 	Type      string          `json:"t"`
 	RawData   json.RawMessage `json:"d"`
 	// Struct contains one of the other types in this file.
@ -37,19 +36,19 @@ type Event struct {

 // A Ready stores all data for the websocket READY event.
 type Ready struct {
-	Version           int           `json:"v"`
-	SessionID         string        `json:"session_id"`
-	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
-	User              *User         `json:"user"`
-	ReadState         []*ReadState  `json:"read_state"`
-	PrivateChannels   []*Channel    `json:"private_channels"`
-	Guilds            []*Guild      `json:"guilds"`
+	Version         int          `json:"v"`
+	SessionID       string       `json:"session_id"`
+	User            *User        `json:"user"`
+	ReadState       []*ReadState `json:"read_state"`
+	PrivateChannels []*Channel   `json:"private_channels"`
+	Guilds          []*Guild     `json:"guilds"`

 	// Undocumented fields
 	Settings          *Settings            `json:"user_settings"`
 	UserGuildSettings []*UserGuildSettings `json:"user_guild_settings"`
 	Relationships     []*Relationship      `json:"relationships"`
 	Presences         []*Presence          `json:"presences"`
+	Notes             map[string]string    `json:"notes"`
 }

 // ChannelCreate is the data for a ChannelCreate event.
@ -179,6 +178,11 @@ type MessageReactionRemove struct {
 	*MessageReaction
 }

+// MessageReactionRemoveAll is the data for a MessageReactionRemoveAll event.
+type MessageReactionRemoveAll struct {
+	*MessageReaction
+}
+
 // PresencesReplace is the data for a PresencesReplace event.
 type PresencesReplace []*Presence

@ -191,8 +195,7 @@ type PresenceUpdate struct {

 // Resumed is the data for a Resumed event.
 type Resumed struct {
-	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
-	Trace             []string      `json:"_trace"`
+	Trace []string `json:"_trace"`
 }

 // RelationshipAdd is the data for a RelationshipAdd event.
@ -225,6 +228,12 @@ type UserGuildSettingsUpdate struct {
 	*UserGuildSettings
 }

+// UserNoteUpdate is the data for a UserNoteUpdate event.
+type UserNoteUpdate struct {
+	ID   string `json:"id"`
+	Note string `json:"note"`
+}
+
 // VoiceServerUpdate is the data for a VoiceServerUpdate event.
 type VoiceServerUpdate struct {
 	Token    string `json:"token"`
@ -236,3 +245,9 @@ type VoiceServerUpdate struct {
 type VoiceStateUpdate struct {
 	*VoiceState
 }
+
+// MessageDeleteBulk is the data for a MessageDeleteBulk event
+type MessageDeleteBulk struct {
+	Messages  []string `json:"ids"`
+	ChannelID string   `json:"channel_id"`
+}
--- a/vendor/github.com/bwmarrin/discordgo/examples/airhorn/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/airhorn/main.go
@ -6,7 +6,9 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"time"

 	"github.com/bwmarrin/discordgo"
@ -21,6 +23,7 @@ var token string
 var buffer = make([][]byte, 0)

 func main() {
+
 	if token == "" {
 		fmt.Println("No token provided. Please run: airhorn -t <bot token>")
 		return
@ -56,21 +59,37 @@ func main() {
 		fmt.Println("Error opening Discord session: ", err)
 	}

+	// Wait here until CTRL-C or other term signal is received.
 	fmt.Println("Airhorn is now running.  Press CTRL-C to exit.")
-	// Simple way to keep program running until CTRL-C is pressed.
-	<-make(chan struct{})
-	return
+	sc := make(chan os.Signal, 1)
+	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
+	<-sc
+
+	// Cleanly close down the Discord session.
+	dg.Close()
 }

+// This function will be called (due to AddHandler above) when the bot receives
+// the "ready" event from Discord.
 func ready(s *discordgo.Session, event *discordgo.Ready) {
+
 	// Set the playing status.
-	_ = s.UpdateStatus(0, "!airhorn")
+	s.UpdateStatus(0, "!airhorn")
 }

 // This function will be called (due to AddHandler above) every time a new
 // message is created on any channel that the autenticated bot has access to.
 func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
+
+	// Ignore all messages created by the bot itself
+	// This isn't required in this specific example but it's a good practice.
+	if m.Author.ID == s.State.User.ID {
+		return
+	}
+
+	// check if the message is "!airhorn"
 	if strings.HasPrefix(m.Content, "!airhorn") {
+
 		// Find the channel that the message came from.
 		c, err := s.State.Channel(m.ChannelID)
 		if err != nil {
@ -85,7 +104,7 @@ func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 			return
 		}

-		// Look for the message sender in that guilds current voice states.
+		// Look for the message sender in that guild's current voice states.
 		for _, vs := range g.VoiceStates {
 			if vs.UserID == m.Author.ID {
 				err = playSound(s, g.ID, vs.ChannelID)
@ -102,6 +121,7 @@ func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
 // This function will be called (due to AddHandler above) every time a new
 // guild is joined.
 func guildCreate(s *discordgo.Session, event *discordgo.GuildCreate) {
+
 	if event.Guild.Unavailable {
 		return
 	}
@ -116,8 +136,8 @@ func guildCreate(s *discordgo.Session, event *discordgo.GuildCreate) {

 // loadSound attempts to load an encoded sound file from disk.
 func loadSound() error {
-	file, err := os.Open("airhorn.dca")

+	file, err := os.Open("airhorn.dca")
 	if err != nil {
 		fmt.Println("Error opening dca file :", err)
 		return err
@ -131,7 +151,7 @@ func loadSound() error {

 		// If this is the end of the file, just return.
 		if err == io.EOF || err == io.ErrUnexpectedEOF {
-			file.Close()
+			err := file.Close()
 			if err != nil {
 				return err
 			}
@ -160,6 +180,7 @@ func loadSound() error {

 // playSound plays the current buffer to the provided channel.
 func playSound(s *discordgo.Session, guildID, channelID string) (err error) {
+
 	// Join the provided voice channel.
 	vc, err := s.ChannelVoiceJoin(guildID, channelID, false, true)
 	if err != nil {
@ -170,7 +191,7 @@ func playSound(s *discordgo.Session, guildID, channelID string) (err error) {
 	time.Sleep(250 * time.Millisecond)

 	// Start speaking.
-	_ = vc.Speaking(true)
+	vc.Speaking(true)

 	// Send the buffer data.
 	for _, buff := range buffer {
@ -178,13 +199,13 @@ func playSound(s *discordgo.Session, guildID, channelID string) (err error) {
 	}

 	// Stop speaking
-	_ = vc.Speaking(false)
+	vc.Speaking(false)

 	// Sleep for a specificed amount of time before ending.
 	time.Sleep(250 * time.Millisecond)

 	// Disconnect from the provided voice channel.
-	_ = vc.Disconnect()
+	vc.Disconnect()

 	return nil
 }
--- a/vendor/github.com/bwmarrin/discordgo/examples/appmaker/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/appmaker/main.go
@ -1,38 +1,42 @@
 package main

 import (
+	"encoding/json"
 	"flag"
 	"fmt"
+	"os"

 	"github.com/bwmarrin/discordgo"
 )

 // Variables used for command line options
 var (
-	Email    string
-	Password string
 	Token    string
-	AppName  string
+	Name     string
 	DeleteID string
 	ListOnly bool
 )

 func init() {

-	flag.StringVar(&Email, "e", "", "Account Email")
-	flag.StringVar(&Password, "p", "", "Account Password")
-	flag.StringVar(&Token, "t", "", "Account Token")
+	flag.StringVar(&Token, "t", "", "Owner Account Token")
+	flag.StringVar(&Name, "n", "", "Name to give App/Bot")
 	flag.StringVar(&DeleteID, "d", "", "Application ID to delete")
 	flag.BoolVar(&ListOnly, "l", false, "List Applications Only")
-	flag.StringVar(&AppName, "a", "", "App/Bot Name")
 	flag.Parse()
+
+	if Token == "" {
+		flag.Usage()
+		os.Exit(1)
+	}
 }

 func main() {

 	var err error
+
 	// Create a new Discord session using the provided login information.
-	dg, err := discordgo.New(Email, Password, Token)
+	dg, err := discordgo.New(Token)
 	if err != nil {
 		fmt.Println("error creating Discord session,", err)
 		return
@ -41,18 +45,17 @@ func main() {
 	// If -l set, only display a list of existing applications
 	// for the given account.
 	if ListOnly {
-		aps, err2 := dg.Applications()
-		if err2 != nil {
+
+		aps, err := dg.Applications()
+		if err != nil {
 			fmt.Println("error fetching applications,", err)
 			return
 		}

-		for k, v := range aps {
-			fmt.Printf("%d : --------------------------------------\n", k)
-			fmt.Printf("ID: %s\n", v.ID)
-			fmt.Printf("Name: %s\n", v.Name)
-			fmt.Printf("Secret: %s\n", v.Secret)
-			fmt.Printf("Description: %s\n", v.Description)
+		for _, v := range aps {
+			fmt.Println("-----------------------------------------------------")
+			b, _ := json.MarshalIndent(v, "", " ")
+			fmt.Println(string(b))
 		}
 		return
 	}
@ -66,9 +69,14 @@ func main() {
 		return
 	}

+	if Name == "" {
+		flag.Usage()
+		os.Exit(1)
+	}
+
 	// Create a new application.
 	ap := &discordgo.Application{}
-	ap.Name = AppName
+	ap.Name = Name
 	ap, err = dg.ApplicationCreate(ap)
 	if err != nil {
 		fmt.Println("error creating new applicaiton,", err)
@ -76,9 +84,8 @@ func main() {
 	}

 	fmt.Printf("Application created successfully:\n")
-	fmt.Printf("ID: %s\n", ap.ID)
-	fmt.Printf("Name: %s\n", ap.Name)
-	fmt.Printf("Secret: %s\n\n", ap.Secret)
+	b, _ := json.MarshalIndent(ap, "", " ")
+	fmt.Println(string(b))

 	// Create the bot account under the application we just created
 	bot, err := dg.ApplicationBotCreate(ap.ID)
@ -88,11 +95,9 @@ func main() {
 	}

 	fmt.Printf("Bot account created successfully.\n")
-	fmt.Printf("ID: %s\n", bot.ID)
-	fmt.Printf("Username: %s\n", bot.Username)
-	fmt.Printf("Token: %s\n\n", bot.Token)
+	b, _ = json.MarshalIndent(bot, "", " ")
+	fmt.Println(string(b))
+
 	fmt.Println("Please save the above posted info in a secure place.")
 	fmt.Println("You will need that information to login with your bot account.")
-
-	return
 }
--- a/vendor/github.com/bwmarrin/discordgo/examples/avatar/localfile/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/avatar/localfile/main.go
@ -1,73 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/bwmarrin/discordgo"
-)
-
-// Variables used for command line parameters
-var (
-	Email       string
-	Password    string
-	Token       string
-	Avatar      string
-	BotID       string
-	BotUsername string
-)
-
-func init() {
-
-	flag.StringVar(&Email, "e", "", "Account Email")
-	flag.StringVar(&Password, "p", "", "Account Password")
-	flag.StringVar(&Token, "t", "", "Account Token")
-	flag.StringVar(&Avatar, "f", "./avatar.jpg", "Avatar File Name")
-	flag.Parse()
-}
-
-func main() {
-
-	// Create a new Discord session using the provided login information.
-	// Use discordgo.New(Token) to just use a token for login.
-	dg, err := discordgo.New(Email, Password, Token)
-	if err != nil {
-		fmt.Println("error creating Discord session,", err)
-		return
-	}
-
-	bot, err := dg.User("@me")
-	if err != nil {
-		fmt.Println("error fetching the bot details,", err)
-		return
-	}
-
-	BotID = bot.ID
-	BotUsername = bot.Username
-	changeAvatar(dg)
-
-	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
-	// Simple way to keep program running until CTRL-C is pressed.
-	<-make(chan struct{})
-	return
-}
-
-// Helper function to change the avatar
-func changeAvatar(s *discordgo.Session) {
-	img, err := ioutil.ReadFile(Avatar)
-	if err != nil {
-		fmt.Println(err)
-	}
-
-	base64 := base64.StdEncoding.EncodeToString(img)
-
-	avatar := fmt.Sprintf("data:%s;base64,%s", http.DetectContentType(img), base64)
-
-	_, err = s.UserUpdate("", "", BotUsername, avatar, "")
-	if err != nil {
-		fmt.Println(err)
-	}
-}
--- a/vendor/github.com/bwmarrin/discordgo/examples/avatar/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/avatar/main.go
@ -0,0 +1,89 @@
+package main
+
+import (
+	"encoding/base64"
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// Variables used for command line parameters
+var (
+	Token      string
+	AvatarFile string
+	AvatarURL  string
+)
+
+func init() {
+
+	flag.StringVar(&Token, "t", "", "Bot Token")
+	flag.StringVar(&AvatarFile, "f", "", "Avatar File Name")
+	flag.StringVar(&AvatarURL, "u", "", "URL to the avatar image")
+	flag.Parse()
+
+	if Token == "" || (AvatarFile == "" && AvatarURL == "") {
+		flag.Usage()
+		os.Exit(1)
+	}
+}
+
+func main() {
+
+	// Create a new Discord session using the provided login information.
+	dg, err := discordgo.New("Bot " + Token)
+	if err != nil {
+		fmt.Println("error creating Discord session,", err)
+		return
+	}
+
+	// Declare these here so they can be used in the below two if blocks and
+	// still carry over to the end of this function.
+	var base64img string
+	var contentType string
+
+	// If we're using a URL link for the Avatar
+	if AvatarURL != "" {
+
+		resp, err := http.Get(AvatarURL)
+		if err != nil {
+			fmt.Println("Error retrieving the file, ", err)
+			return
+		}
+
+		defer func() {
+			_ = resp.Body.Close()
+		}()
+
+		img, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			fmt.Println("Error reading the response, ", err)
+			return
+		}
+
+		contentType = http.DetectContentType(img)
+		base64img = base64.StdEncoding.EncodeToString(img)
+	}
+
+	// If we're using a local file for the Avatar
+	if AvatarFile != "" {
+		img, err := ioutil.ReadFile(AvatarFile)
+		if err != nil {
+			fmt.Println(err)
+		}
+
+		contentType = http.DetectContentType(img)
+		base64img = base64.StdEncoding.EncodeToString(img)
+	}
+
+	// Now lets format our base64 image into the proper format Discord wants
+	// and then call UserUpdate to set it as our user's Avatar.
+	avatar := fmt.Sprintf("data:%s;base64,%s", contentType, base64img)
+	_, err = dg.UserUpdate("", "", "", avatar, "")
+	if err != nil {
+		fmt.Println(err)
+	}
+}
--- a/vendor/github.com/bwmarrin/discordgo/examples/avatar/url/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/avatar/url/main.go
@ -1,86 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-
-	"github.com/bwmarrin/discordgo"
-)
-
-// Variables used for command line parameters
-var (
-	Email       string
-	Password    string
-	Token       string
-	URL         string
-	BotID       string
-	BotUsername string
-)
-
-func init() {
-
-	flag.StringVar(&Email, "e", "", "Account Email")
-	flag.StringVar(&Password, "p", "", "Account Password")
-	flag.StringVar(&Token, "t", "", "Account Token")
-	flag.StringVar(&URL, "l", "http://bwmarrin.github.io/discordgo/img/discordgo.png", "Link to the avatar image")
-	flag.Parse()
-}
-
-func main() {
-
-	// Create a new Discord session using the provided login information.
-	// Use discordgo.New(Token) to just use a token for login.
-	dg, err := discordgo.New(Email, Password, Token)
-	if err != nil {
-		fmt.Println("error creating Discord session,", err)
-		return
-	}
-
-	bot, err := dg.User("@me")
-	if err != nil {
-		fmt.Println("error fetching the bot details,", err)
-		return
-	}
-
-	BotID = bot.ID
-	BotUsername = bot.Username
-	changeAvatar(dg)
-
-	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
-	// Simple way to keep program running until CTRL-C is pressed.
-	<-make(chan struct{})
-	return
-}
-
-// Helper function to change the avatar
-func changeAvatar(s *discordgo.Session) {
-
-	resp, err := http.Get(URL)
-	if err != nil {
-		fmt.Println("Error retrieving the file, ", err)
-		return
-	}
-
-	defer func() {
-		_ = resp.Body.Close()
-	}()
-
-	img, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Println("Error reading the response, ", err)
-		return
-	}
-
-	base64 := base64.StdEncoding.EncodeToString(img)
-
-	avatar := fmt.Sprintf("data:%s;base64,%s", http.DetectContentType(img), base64)
-
-	_, err = s.UserUpdate("", "", BotUsername, avatar, "")
-	if err != nil {
-		fmt.Println("Error setting the avatar, ", err)
-	}
-
-}
--- a/vendor/github.com/bwmarrin/discordgo/examples/mytoken/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/mytoken/main.go
@ -3,6 +3,7 @@ package main
 import (
 	"flag"
 	"fmt"
+	"os"

 	"github.com/bwmarrin/discordgo"
 )
@ -18,6 +19,11 @@ func init() {
 	flag.StringVar(&Email, "e", "", "Account Email")
 	flag.StringVar(&Password, "p", "", "Account Password")
 	flag.Parse()
+
+	if Email == "" || Password == "" {
+		flag.Usage()
+		os.Exit(1)
+	}
 }

 func main() {
@ -29,5 +35,6 @@ func main() {
 		return
 	}

+	// Print out your token.
 	fmt.Printf("Your Authentication Token is:\n\n%s\n", dg.Token)
 }
--- a/vendor/github.com/bwmarrin/discordgo/examples/new_basic/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/new_basic/main.go
@ -1,53 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"time"
-
-	"github.com/bwmarrin/discordgo"
-)
-
-// Variables used for command line parameters
-var (
-	Token string
-)
-
-func init() {
-
-	flag.StringVar(&Token, "t", "", "Bot Token")
-	flag.Parse()
-}
-
-func main() {
-
-	// Create a new Discord session using the provided bot token.
-	dg, err := discordgo.New("Bot " + Token)
-	if err != nil {
-		fmt.Println("error creating Discord session,", err)
-		return
-	}
-
-	// Register messageCreate as a callback for the messageCreate events.
-	dg.AddHandler(messageCreate)
-
-	// Open the websocket and begin listening.
-	err = dg.Open()
-	if err != nil {
-		fmt.Println("error opening connection,", err)
-		return
-	}
-
-	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
-	// Simple way to keep program running until CTRL-C is pressed.
-	<-make(chan struct{})
-	return
-}
-
-// This function will be called (due to AddHandler above) every time a new
-// message is created on any channel that the autenticated bot has access to.
-func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {
-
-	// Print message to stdout.
-	fmt.Printf("%20s %20s %20s > %s\n", m.ChannelID, time.Now().Format(time.Stamp), m.Author.Username, m.Content)
-}
--- a/vendor/github.com/bwmarrin/discordgo/examples/pingpong/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/examples/pingpong/main.go
@ -3,6 +3,9 @@ package main
 import (
 	"flag"
 	"fmt"
+	"os"
+	"os/signal"
+	"syscall"

 	"github.com/bwmarrin/discordgo"
 )
@ -10,7 +13,6 @@ import (
 // Variables used for command line parameters
 var (
 	Token string
-	BotID string
 )

 func init() {
@ -28,29 +30,24 @@ func main() {
 		return
 	}

-	// Get the account information.
-	u, err := dg.User("@me")
-	if err != nil {
-		fmt.Println("error obtaining account details,", err)
-	}
-
-	// Store the account ID for later use.
-	BotID = u.ID
-
-	// Register messageCreate as a callback for the messageCreate events.
+	// Register the messageCreate func as a callback for MessageCreate events.
 	dg.AddHandler(messageCreate)

-	// Open the websocket and begin listening.
+	// Open a websocket connection to Discord and begin listening.
 	err = dg.Open()
 	if err != nil {
 		fmt.Println("error opening connection,", err)
 		return
 	}

+	// Wait here until CTRL-C or other term signal is received.
 	fmt.Println("Bot is now running.  Press CTRL-C to exit.")
-	// Simple way to keep program running until CTRL-C is pressed.
-	<-make(chan struct{})
-	return
+	sc := make(chan os.Signal, 1)
+	signal.Notify(sc, syscall.SIGINT, syscall.SIGTERM, os.Interrupt, os.Kill)
+	<-sc
+
+	// Cleanly close down the Discord session.
+	dg.Close()
 }

 // This function will be called (due to AddHandler above) every time a new
@ -58,17 +55,17 @@ func main() {
 func messageCreate(s *discordgo.Session, m *discordgo.MessageCreate) {

 	// Ignore all messages created by the bot itself
-	if m.Author.ID == BotID {
+	// This isn't required in this specific example but it's a good practice.
+	if m.Author.ID == s.State.User.ID {
 		return
 	}
-
 	// If the message is "ping" reply with "Pong!"
 	if m.Content == "ping" {
-		_, _ = s.ChannelMessageSend(m.ChannelID, "Pong!")
+		s.ChannelMessageSend(m.ChannelID, "Pong!")
 	}

 	// If the message is "pong" reply with "Ping!"
 	if m.Content == "pong" {
-		_, _ = s.ChannelMessageSend(m.ChannelID, "Ping!")
+		s.ChannelMessageSend(m.ChannelID, "Ping!")
 	}
 }
--- a/vendor/github.com/bwmarrin/discordgo/message.go
+++ b/vendor/github.com/bwmarrin/discordgo/message.go
@ -11,6 +11,7 @@ package discordgo

 import (
 	"fmt"
+	"io"
 	"regexp"
 )

@ -31,6 +32,53 @@ type Message struct {
 	Reactions       []*MessageReactions  `json:"reactions"`
 }

+// File stores info about files you e.g. send in messages.
+type File struct {
+	Name   string
+	Reader io.Reader
+}
+
+// MessageSend stores all parameters you can send with ChannelMessageSendComplex.
+type MessageSend struct {
+	Content string        `json:"content,omitempty"`
+	Embed   *MessageEmbed `json:"embed,omitempty"`
+	Tts     bool          `json:"tts"`
+	File    *File         `json:"file"`
+}
+
+// MessageEdit is used to chain parameters via ChannelMessageEditComplex, which
+// is also where you should get the instance from.
+type MessageEdit struct {
+	Content *string       `json:"content,omitempty"`
+	Embed   *MessageEmbed `json:"embed,omitempty"`
+
+	ID      string
+	Channel string
+}
+
+// NewMessageEdit returns a MessageEdit struct, initialized
+// with the Channel and ID.
+func NewMessageEdit(channelID string, messageID string) *MessageEdit {
+	return &MessageEdit{
+		Channel: channelID,
+		ID:      messageID,
+	}
+}
+
+// SetContent is the same as setting the variable Content,
+// except it doesn't take a pointer.
+func (m *MessageEdit) SetContent(str string) *MessageEdit {
+	m.Content = &str
+	return m
+}
+
+// SetEmbed is a convenience function for setting the embed,
+// so you can chain commands.
+func (m *MessageEdit) SetEmbed(embed *MessageEmbed) *MessageEdit {
+	m.Embed = embed
+	return m
+}
+
 // A MessageAttachment stores data for message attachments.
 type MessageAttachment struct {
 	ID       string `json:"id"`
--- a/vendor/github.com/bwmarrin/discordgo/oauth2.go
+++ b/vendor/github.com/bwmarrin/discordgo/oauth2.go
@ -15,13 +15,18 @@ package discordgo

 // An Application struct stores values for a Discord OAuth2 Application
 type Application struct {
-	ID           string    `json:"id,omitempty"`
-	Name         string    `json:"name"`
-	Description  string    `json:"description,omitempty"`
-	Icon         string    `json:"icon,omitempty"`
-	Secret       string    `json:"secret,omitempty"`
-	RedirectURIs *[]string `json:"redirect_uris,omitempty"`
-	Owner        *User     `json:"owner"`
+	ID                  string    `json:"id,omitempty"`
+	Name                string    `json:"name"`
+	Description         string    `json:"description,omitempty"`
+	Icon                string    `json:"icon,omitempty"`
+	Secret              string    `json:"secret,omitempty"`
+	RedirectURIs        *[]string `json:"redirect_uris,omitempty"`
+	BotRequireCodeGrant bool      `json:"bot_require_code_grant,omitempty"`
+	BotPublic           bool      `json:"bot_public,omitempty"`
+	RPCApplicationState int       `json:"rpc_application_state,omitempty"`
+	Flags               int       `json:"flags,omitempty"`
+	Owner               *User     `json:"owner"`
+	Bot                 *User     `json:"bot"`
 }

 // Application returns an Application structure of a specific Application
--- a/vendor/github.com/bwmarrin/discordgo/ratelimit.go
+++ b/vendor/github.com/bwmarrin/discordgo/ratelimit.go
@ -4,13 +4,14 @@ import (
 	"net/http"
 	"strconv"
 	"sync"
+	"sync/atomic"
 	"time"
 )

 // RateLimiter holds all ratelimit buckets
 type RateLimiter struct {
 	sync.Mutex
-	global          *Bucket
+	global          *int64
 	buckets         map[string]*Bucket
 	globalRateLimit time.Duration
 }
@ -20,7 +21,7 @@ func NewRatelimiter() *RateLimiter {

 	return &RateLimiter{
 		buckets: make(map[string]*Bucket),
-		global:  &Bucket{Key: "global"},
+		global:  new(int64),
 	}
 }

@ -58,8 +59,10 @@ func (r *RateLimiter) LockBucket(bucketID string) *Bucket {
 	}

 	// Check for global ratelimits
-	r.global.Lock()
-	r.global.Unlock()
+	sleepTo := time.Unix(0, atomic.LoadInt64(r.global))
+	if now := time.Now(); now.Before(sleepTo) {
+		time.Sleep(sleepTo.Sub(now))
+	}

 	b.remaining--
 	return b
@ -72,7 +75,7 @@ type Bucket struct {
 	remaining int
 	limit     int
 	reset     time.Time
-	global    *Bucket
+	global    *int64
 }

 // Release unlocks the bucket and reads the headers to update the buckets ratelimit info
@ -89,41 +92,25 @@ func (b *Bucket) Release(headers http.Header) error {
 	global := headers.Get("X-RateLimit-Global")
 	retryAfter := headers.Get("Retry-After")

-	// If it's global just keep the main ratelimit mutex locked
-	if global != "" {
-		parsedAfter, err := strconv.Atoi(retryAfter)
-		if err != nil {
-			return err
-		}
-
-		// Lock it in a new goroutine so that this isn't a blocking call
-		go func() {
-			// Make sure if several requests were waiting we don't sleep for n * retry-after
-			// where n is the amount of requests that were going on
-			sleepTo := time.Now().Add(time.Duration(parsedAfter) * time.Millisecond)
-
-			b.global.Lock()
-
-			sleepDuration := sleepTo.Sub(time.Now())
-			if sleepDuration > 0 {
-				time.Sleep(sleepDuration)
-			}
-
-			b.global.Unlock()
-		}()
-
-		return nil
-	}
-
-	// Update reset time if either retry after or reset headers are present
-	// Prefer retryafter because it's more accurate with time sync and whatnot
+	// Update global and per bucket reset time if the proper headers are available
+	// If global is set, then it will block all buckets until after Retry-After
+	// If Retry-After without global is provided it will use that for the new reset
+	// time since it's more accurate than X-RateLimit-Reset.
+	// If Retry-After after is not proided, it will update the reset time from X-RateLimit-Reset
 	if retryAfter != "" {
 		parsedAfter, err := strconv.ParseInt(retryAfter, 10, 64)
 		if err != nil {
 			return err
 		}
-		b.reset = time.Now().Add(time.Duration(parsedAfter) * time.Millisecond)

+		resetAt := time.Now().Add(time.Duration(parsedAfter) * time.Millisecond)
+
+		// Lock either this single bucket or all buckets
+		if global != "" {
+			atomic.StoreInt64(b.global, resetAt.UnixNano())
+		} else {
+			b.reset = resetAt
+		}
 	} else if reset != "" {
 		// Calculate the reset time by using the date header returned from discord
 		discordTime, err := http.ParseTime(headers.Get("Date"))
--- a/vendor/github.com/bwmarrin/discordgo/restapi.go
+++ b/vendor/github.com/bwmarrin/discordgo/restapi.go
@ -29,8 +29,15 @@ import (
 	"time"
 )

-// ErrJSONUnmarshal is returned for JSON Unmarshall errors.
-var ErrJSONUnmarshal = errors.New("json unmarshal")
+// All error constants
+var (
+	ErrJSONUnmarshal           = errors.New("json unmarshal")
+	ErrStatusOffline           = errors.New("You can't set your Status to offline")
+	ErrVerificationLevelBounds = errors.New("VerificationLevel out of bounds, should be between 0 and 3")
+	ErrPruneDaysBounds         = errors.New("the number of days should be more than or equal to 1")
+	ErrGuildNoIcon             = errors.New("guild does not have an icon set")
+	ErrGuildNoSplash           = errors.New("guild does not have a splash set")
+)

 // Request is the same as RequestWithBucketID but the bucket id is the same as the urlStr
 func (s *Session) Request(method, urlStr string, data interface{}) (response []byte, err error) {
@ -87,9 +94,7 @@ func (s *Session) request(method, urlStr, contentType string, b []byte, bucketID
 		}
 	}

-	client := &http.Client{Timeout: (20 * time.Second)}
-
-	resp, err := client.Do(req)
+	resp, err := s.Client.Do(req)
 	if err != nil {
 		bucket.Release(nil)
 		return
@ -175,6 +180,12 @@ func unmarshal(data []byte, v interface{}) error {
 // ------------------------------------------------------------------------------------------------

 // Login asks the Discord server for an authentication token.
+//
+// NOTE: While email/pass authentication is supported by DiscordGo it is
+// HIGHLY DISCOURAGED by Discord. Please only use email/pass to obtain a token
+// and then use that authentication token for all future connections.
+// Also, doing any form of automation with a user (non Bot) account may result
+// in that account being permanently banned from Discord.
 func (s *Session) Login(email, password string) (err error) {

 	data := struct {
@ -189,6 +200,7 @@ func (s *Session) Login(email, password string) (err error) {

 	temp := struct {
 		Token string `json:"token"`
+		MFA   bool   `json:"mfa"`
 	}{}

 	err = unmarshal(response, &temp)
@ -197,6 +209,7 @@ func (s *Session) Login(email, password string) (err error) {
 	}

 	s.Token = temp.Token
+	s.MFA = temp.MFA
 	return
 }

@ -264,15 +277,21 @@ func (s *Session) User(userID string) (st *User, err error) {
 	return
 }

-// UserAvatar returns an image.Image of a users Avatar.
+// UserAvatar is deprecated. Please use UserAvatarDecode
 // userID    : A user ID or "@me" which is a shortcut of current user ID
 func (s *Session) UserAvatar(userID string) (img image.Image, err error) {
 	u, err := s.User(userID)
 	if err != nil {
 		return
 	}
+	img, err = s.UserAvatarDecode(u)
+	return
+}

-	body, err := s.RequestWithBucketID("GET", EndpointUserAvatar(userID, u.Avatar), nil, EndpointUserAvatar("", ""))
+// UserAvatarDecode returns an image.Image of a user's Avatar
+// user : The user which avatar should be retrieved
+func (s *Session) UserAvatarDecode(u *User) (img image.Image, err error) {
+	body, err := s.RequestWithBucketID("GET", EndpointUserAvatar(u.ID, u.Avatar), nil, EndpointUserAvatar("", ""))
 	if err != nil {
 		return
 	}
@ -292,7 +311,7 @@ func (s *Session) UserUpdate(email, password, username, avatar, newPassword stri
 	data := struct {
 		Email       string `json:"email"`
 		Password    string `json:"password"`
-		Username    string `json:"username"`
+		Username    string `json:"username,omitempty"`
 		Avatar      string `json:"avatar,omitempty"`
 		NewPassword string `json:"new_password,omitempty"`
 	}{email, password, username, avatar, newPassword}
@ -322,7 +341,7 @@ func (s *Session) UserSettings() (st *Settings, err error) {
 // status   : The new status (Actual valid status are 'online','idle','dnd','invisible')
 func (s *Session) UserUpdateStatus(status Status) (st *Settings, err error) {
 	if status == StatusOffline {
-		err = errors.New("You can't set your Status to offline")
+		err = ErrStatusOffline
 		return
 	}

@ -370,9 +389,30 @@ func (s *Session) UserChannelCreate(recipientID string) (st *Channel, err error)
 }

 // UserGuilds returns an array of UserGuild structures for all guilds.
-func (s *Session) UserGuilds() (st []*UserGuild, err error) {
+// limit     : The number guilds that can be returned. (max 100)
+// beforeID  : If provided all guilds returned will be before given ID.
+// afterID   : If provided all guilds returned will be after given ID.
+func (s *Session) UserGuilds(limit int, beforeID, afterID string) (st []*UserGuild, err error) {

-	body, err := s.RequestWithBucketID("GET", EndpointUserGuilds("@me"), nil, EndpointUserGuilds(""))
+	v := url.Values{}
+
+	if limit > 0 {
+		v.Set("limit", strconv.Itoa(limit))
+	}
+	if afterID != "" {
+		v.Set("after", afterID)
+	}
+	if beforeID != "" {
+		v.Set("before", beforeID)
+	}
+
+	uri := EndpointUserGuilds("@me")
+
+	if len(v) > 0 {
+		uri = fmt.Sprintf("%s?%s", uri, v.Encode())
+	}
+
+	body, err := s.RequestWithBucketID("GET", uri, nil, EndpointUserGuilds(""))
 	if err != nil {
 		return
 	}
@ -402,6 +442,13 @@ func (s *Session) UserGuildSettingsEdit(guildID string, settings *UserGuildSetti
 // NOTE: This function is now deprecated and will be removed in the future.
 // Please see the same function inside state.go
 func (s *Session) UserChannelPermissions(userID, channelID string) (apermissions int, err error) {
+	// Try to just get permissions from state.
+	apermissions, err = s.State.UserChannelPermissions(userID, channelID)
+	if err == nil {
+		return
+	}
+
+	// Otherwise try get as much data from state as possible, falling back to the network.
 	channel, err := s.State.Channel(channelID)
 	if err != nil || channel == nil {
 		channel, err = s.Channel(channelID)
@ -431,6 +478,19 @@ func (s *Session) UserChannelPermissions(userID, channelID string) (apermissions
 		}
 	}

+	return memberPermissions(guild, channel, member), nil
+}
+
+// Calculates the permissions for a member.
+// https://support.discordapp.com/hc/en-us/articles/206141927-How-is-the-permission-hierarchy-structured-
+func memberPermissions(guild *Guild, channel *Channel, member *Member) (apermissions int) {
+	userID := member.User.ID
+
+	if userID == guild.OwnerID {
+		apermissions = PermissionAll
+		return
+	}
+
 	for _, role := range guild.Roles {
 		if role.ID == guild.ID {
 			apermissions |= role.Permissions
@ -447,21 +507,36 @@ func (s *Session) UserChannelPermissions(userID, channelID string) (apermissions
 		}
 	}

-	if apermissions&PermissionAdministrator > 0 {
+	if apermissions&PermissionAdministrator == PermissionAdministrator {
 		apermissions |= PermissionAll
 	}

+	// Apply @everyone overrides from the channel.
+	for _, overwrite := range channel.PermissionOverwrites {
+		if guild.ID == overwrite.ID {
+			apermissions &= ^overwrite.Deny
+			apermissions |= overwrite.Allow
+			break
+		}
+	}
+
+	denies := 0
+	allows := 0
+
 	// Member overwrites can override role overrides, so do two passes
 	for _, overwrite := range channel.PermissionOverwrites {
 		for _, roleID := range member.Roles {
 			if overwrite.Type == "role" && roleID == overwrite.ID {
-				apermissions &= ^overwrite.Deny
-				apermissions |= overwrite.Allow
+				denies |= overwrite.Deny
+				allows |= overwrite.Allow
 				break
 			}
 		}
 	}

+	apermissions &= ^denies
+	apermissions |= allows
+
 	for _, overwrite := range channel.PermissionOverwrites {
 		if overwrite.Type == "member" && overwrite.ID == userID {
 			apermissions &= ^overwrite.Deny
@ -470,11 +545,11 @@ func (s *Session) UserChannelPermissions(userID, channelID string) (apermissions
 		}
 	}

-	if apermissions&PermissionAdministrator > 0 {
+	if apermissions&PermissionAdministrator == PermissionAdministrator {
 		apermissions |= PermissionAllChannel
 	}

-	return
+	return apermissions
 }

 // ------------------------------------------------------------------------------------------------
@ -527,7 +602,7 @@ func (s *Session) GuildEdit(guildID string, g GuildParams) (st *Guild, err error
 	if g.VerificationLevel != nil {
 		val := *g.VerificationLevel
 		if val < 0 || val > 3 {
-			err = errors.New("VerificationLevel out of bounds, should be between 0 and 3")
+			err = ErrVerificationLevelBounds
 			return
 		}
 	}
@ -551,13 +626,7 @@ func (s *Session) GuildEdit(guildID string, g GuildParams) (st *Guild, err error
 		}
 	}

-	data := struct {
-		Name              string             `json:"name,omitempty"`
-		Region            string             `json:"region,omitempty"`
-		VerificationLevel *VerificationLevel `json:"verification_level,omitempty"`
-	}{g.Name, g.Region, g.VerificationLevel}
-
-	body, err := s.RequestWithBucketID("PATCH", EndpointGuild(guildID), data, EndpointGuild(guildID))
+	body, err := s.RequestWithBucketID("PATCH", EndpointGuild(guildID), g, EndpointGuild(guildID))
 	if err != nil {
 		return
 	}
@ -607,11 +676,28 @@ func (s *Session) GuildBans(guildID string) (st []*GuildBan, err error) {
 // userID    : The ID of a User
 // days      : The number of days of previous comments to delete.
 func (s *Session) GuildBanCreate(guildID, userID string, days int) (err error) {
+	return s.GuildBanCreateWithReason(guildID, userID, "", days)
+}
+
+// GuildBanCreateWithReason bans the given user from the given guild also providing a reaso.
+// guildID   : The ID of a Guild.
+// userID    : The ID of a User
+// reason    : The reason for this ban
+// days      : The number of days of previous comments to delete.
+func (s *Session) GuildBanCreateWithReason(guildID, userID, reason string, days int) (err error) {

 	uri := EndpointGuildBan(guildID, userID)

+	queryParams := url.Values{}
 	if days > 0 {
-		uri = fmt.Sprintf("%s?delete-message-days=%d", uri, days)
+		queryParams.Set("delete-message-days", strconv.Itoa(days))
+	}
+	if reason != "" {
+		queryParams.Set("reason", reason)
+	}
+
+	if len(queryParams) > 0 {
+		uri += "?" + queryParams.Encode()
 	}

 	_, err = s.RequestWithBucketID("PUT", uri, nil, EndpointGuildBan(guildID, ""))
@ -722,12 +808,17 @@ func (s *Session) GuildMemberMove(guildID, userID, channelID string) (err error)
 // GuildMemberNickname updates the nickname of a guild member
 // guildID   : The ID of a guild
 // userID    : The ID of a user
+// userID    : The ID of a user or "@me" which is a shortcut of the current user ID
 func (s *Session) GuildMemberNickname(guildID, userID, nickname string) (err error) {

 	data := struct {
 		Nick string `json:"nick"`
 	}{nickname}

+	if userID == "@me" {
+		userID += "/nick"
+	}
+
 	_, err = s.RequestWithBucketID("PATCH", EndpointGuildMember(guildID, userID), data, EndpointGuildMember(guildID, ""))
 	return
 }
@ -738,7 +829,7 @@ func (s *Session) GuildMemberNickname(guildID, userID, nickname string) (err err
 //  roleID 	  : The ID of a Role to be assigned to the user.
 func (s *Session) GuildMemberRoleAdd(guildID, userID, roleID string) (err error) {

-	_, err = s.RequestWithBucketID("PUT", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, userID, roleID))
+	_, err = s.RequestWithBucketID("PUT", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, "", ""))

 	return
 }
@ -749,7 +840,7 @@ func (s *Session) GuildMemberRoleAdd(guildID, userID, roleID string) (err error)
 //  roleID 	  : The ID of a Role to be removed from the user.
 func (s *Session) GuildMemberRoleRemove(guildID, userID, roleID string) (err error) {

-	_, err = s.RequestWithBucketID("DELETE", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, userID, roleID))
+	_, err = s.RequestWithBucketID("DELETE", EndpointGuildMemberRole(guildID, userID, roleID), nil, EndpointGuildMemberRole(guildID, "", ""))

 	return
 }
@ -904,7 +995,7 @@ func (s *Session) GuildPruneCount(guildID string, days uint32) (count uint32, er
 	count = 0

 	if days <= 0 {
-		err = errors.New("The number of days should be more than or equal to 1.")
+		err = ErrPruneDaysBounds
 		return
 	}

@ -934,7 +1025,7 @@ func (s *Session) GuildPrune(guildID string, days uint32) (count uint32, err err
 	count = 0

 	if days <= 0 {
-		err = errors.New("The number of days should be more than or equal to 1.")
+		err = ErrPruneDaysBounds
 		return
 	}

@ -1036,7 +1127,7 @@ func (s *Session) GuildIcon(guildID string) (img image.Image, err error) {
 	}

 	if g.Icon == "" {
-		err = errors.New("Guild does not have an icon set.")
+		err = ErrGuildNoIcon
 		return
 	}

@ -1058,7 +1149,7 @@ func (s *Session) GuildSplash(guildID string) (img image.Image, err error) {
 	}

 	if g.Splash == "" {
-		err = errors.New("Guild does not have a splash set.")
+		err = ErrGuildNoSplash
 		return
 	}

@ -1156,7 +1247,8 @@ func (s *Session) ChannelTyping(channelID string) (err error) {
 // limit     : The number messages that can be returned. (max 100)
 // beforeID  : If provided all messages returned will be before given ID.
 // afterID   : If provided all messages returned will be after given ID.
-func (s *Session) ChannelMessages(channelID string, limit int, beforeID, afterID string) (st []*Message, err error) {
+// aroundID  : If provided all messages returned will be around given ID.
+func (s *Session) ChannelMessages(channelID string, limit int, beforeID, afterID, aroundID string) (st []*Message, err error) {

 	uri := EndpointChannelMessages(channelID)

@ -1170,6 +1262,9 @@ func (s *Session) ChannelMessages(channelID string, limit int, beforeID, afterID
 	if beforeID != "" {
 		v.Set("before", beforeID)
 	}
+	if aroundID != "" {
+		v.Set("around", aroundID)
+	}
 	if len(v) > 0 {
 		uri = fmt.Sprintf("%s?%s", uri, v.Encode())
 	}
@ -1212,20 +1307,76 @@ func (s *Session) ChannelMessageAck(channelID, messageID, lastToken string) (st
 	return
 }

-// channelMessageSend sends a message to the given channel.
+// ChannelMessageSend sends a message to the given channel.
 // channelID : The ID of a Channel.
 // content   : The message to send.
-// tts       : Whether to send the message with TTS.
-func (s *Session) channelMessageSend(channelID, content string, tts bool) (st *Message, err error) {
+func (s *Session) ChannelMessageSend(channelID string, content string) (*Message, error) {
+	return s.ChannelMessageSendComplex(channelID, &MessageSend{
+		Content: content,
+	})
+}

-	// TODO: nonce string ?
-	data := struct {
-		Content string `json:"content"`
-		TTS     bool   `json:"tts"`
-	}{content, tts}
+// ChannelMessageSendComplex sends a message to the given channel.
+// channelID : The ID of a Channel.
+// data      : The message struct to send.
+func (s *Session) ChannelMessageSendComplex(channelID string, data *MessageSend) (st *Message, err error) {
+	if data.Embed != nil && data.Embed.Type == "" {
+		data.Embed.Type = "rich"
+	}

-	// Send the message to the given channel
-	response, err := s.RequestWithBucketID("POST", EndpointChannelMessages(channelID), data, EndpointChannelMessages(channelID))
+	endpoint := EndpointChannelMessages(channelID)
+
+	var response []byte
+	if data.File != nil {
+		body := &bytes.Buffer{}
+		bodywriter := multipart.NewWriter(body)
+
+		// What's a better way of doing this? Reflect? Generator? I'm open to suggestions
+
+		if data.Content != "" {
+			if err = bodywriter.WriteField("content", data.Content); err != nil {
+				return
+			}
+		}
+
+		if data.Embed != nil {
+			var embed []byte
+			embed, err = json.Marshal(data.Embed)
+			if err != nil {
+				return
+			}
+			err = bodywriter.WriteField("embed", string(embed))
+			if err != nil {
+				return
+			}
+		}
+
+		if data.Tts {
+			if err = bodywriter.WriteField("tts", "true"); err != nil {
+				return
+			}
+		}
+
+		var writer io.Writer
+		writer, err = bodywriter.CreateFormFile("file", data.File.Name)
+		if err != nil {
+			return
+		}
+
+		_, err = io.Copy(writer, data.File.Reader)
+		if err != nil {
+			return
+		}
+
+		err = bodywriter.Close()
+		if err != nil {
+			return
+		}
+
+		response, err = s.request("POST", endpoint, bodywriter.FormDataContentType(), body.Bytes(), endpoint, 0)
+	} else {
+		response, err = s.RequestWithBucketID("POST", endpoint, data, endpoint)
+	}
 	if err != nil {
 		return
 	}
@ -1234,55 +1385,42 @@ func (s *Session) channelMessageSend(channelID, content string, tts bool) (st *M
 	return
 }

-// ChannelMessageSend sends a message to the given channel.
-// channelID : The ID of a Channel.
-// content   : The message to send.
-func (s *Session) ChannelMessageSend(channelID string, content string) (st *Message, err error) {
-
-	return s.channelMessageSend(channelID, content, false)
-}
-
 // ChannelMessageSendTTS sends a message to the given channel with Text to Speech.
 // channelID : The ID of a Channel.
 // content   : The message to send.
-func (s *Session) ChannelMessageSendTTS(channelID string, content string) (st *Message, err error) {
-
-	return s.channelMessageSend(channelID, content, true)
+func (s *Session) ChannelMessageSendTTS(channelID string, content string) (*Message, error) {
+	return s.ChannelMessageSendComplex(channelID, &MessageSend{
+		Content: content,
+		Tts:     true,
+	})
 }

-// ChannelMessageSendEmbed sends a message to the given channel with embedded data (bot only).
+// ChannelMessageSendEmbed sends a message to the given channel with embedded data.
 // channelID : The ID of a Channel.
 // embed     : The embed data to send.
-func (s *Session) ChannelMessageSendEmbed(channelID string, embed *MessageEmbed) (st *Message, err error) {
-	if embed != nil && embed.Type == "" {
-		embed.Type = "rich"
-	}
-
-	data := struct {
-		Embed *MessageEmbed `json:"embed"`
-	}{embed}
-
-	// Send the message to the given channel
-	response, err := s.RequestWithBucketID("POST", EndpointChannelMessages(channelID), data, EndpointChannelMessages(channelID))
-	if err != nil {
-		return
-	}
-
-	err = unmarshal(response, &st)
-	return
+func (s *Session) ChannelMessageSendEmbed(channelID string, embed *MessageEmbed) (*Message, error) {
+	return s.ChannelMessageSendComplex(channelID, &MessageSend{
+		Embed: embed,
+	})
 }

 // ChannelMessageEdit edits an existing message, replacing it entirely with
 // the given content.
-// channeld  : The ID of a Channel
-// messageID : the ID of a Message
-func (s *Session) ChannelMessageEdit(channelID, messageID, content string) (st *Message, err error) {
+// channelID  : The ID of a Channel
+// messageID  : The ID of a Message
+// content    : The contents of the message
+func (s *Session) ChannelMessageEdit(channelID, messageID, content string) (*Message, error) {
+	return s.ChannelMessageEditComplex(NewMessageEdit(channelID, messageID).SetContent(content))
+}

-	data := struct {
-		Content string `json:"content"`
-	}{content}
+// ChannelMessageEditComplex edits an existing message, replacing it entirely with
+// the given MessageEdit struct
+func (s *Session) ChannelMessageEditComplex(m *MessageEdit) (st *Message, err error) {
+	if m.Embed != nil && m.Embed.Type == "" {
+		m.Embed.Type = "rich"
+	}

-	response, err := s.RequestWithBucketID("PATCH", EndpointChannelMessage(channelID, messageID), data, EndpointChannelMessage(channelID, ""))
+	response, err := s.RequestWithBucketID("PATCH", EndpointChannelMessage(m.Channel, m.ID), m, EndpointChannelMessage(m.Channel, ""))
 	if err != nil {
 		return
 	}
@ -1291,26 +1429,12 @@ func (s *Session) ChannelMessageEdit(channelID, messageID, content string) (st *
 	return
 }

-// ChannelMessageEditEmbed edits an existing message with embedded data (bot only).
+// ChannelMessageEditEmbed edits an existing message with embedded data.
 // channelID : The ID of a Channel
 // messageID : The ID of a Message
 // embed     : The embed data to send
-func (s *Session) ChannelMessageEditEmbed(channelID, messageID string, embed *MessageEmbed) (st *Message, err error) {
-	if embed != nil && embed.Type == "" {
-		embed.Type = "rich"
-	}
-
-	data := struct {
-		Embed *MessageEmbed `json:"embed"`
-	}{embed}
-
-	response, err := s.RequestWithBucketID("PATCH", EndpointChannelMessage(channelID, messageID), data, EndpointChannelMessage(channelID, ""))
-	if err != nil {
-		return
-	}
-
-	err = unmarshal(response, &st)
-	return
+func (s *Session) ChannelMessageEditEmbed(channelID, messageID string, embed *MessageEmbed) (*Message, error) {
+	return s.ChannelMessageEditComplex(NewMessageEdit(channelID, messageID).SetEmbed(embed))
 }

 // ChannelMessageDelete deletes a message from the Channel.
@ -1385,48 +1509,18 @@ func (s *Session) ChannelMessagesPinned(channelID string) (st []*Message, err er
 // channelID : The ID of a Channel.
 // name: The name of the file.
 // io.Reader : A reader for the file contents.
-func (s *Session) ChannelFileSend(channelID, name string, r io.Reader) (st *Message, err error) {
-	return s.ChannelFileSendWithMessage(channelID, "", name, r)
+func (s *Session) ChannelFileSend(channelID, name string, r io.Reader) (*Message, error) {
+	return s.ChannelMessageSendComplex(channelID, &MessageSend{File: &File{Name: name, Reader: r}})
 }

 // ChannelFileSendWithMessage sends a file to the given channel with an message.
+// DEPRECATED. Use ChannelMessageSendComplex instead.
 // channelID : The ID of a Channel.
 // content: Optional Message content.
 // name: The name of the file.
 // io.Reader : A reader for the file contents.
-func (s *Session) ChannelFileSendWithMessage(channelID, content string, name string, r io.Reader) (st *Message, err error) {
-
-	body := &bytes.Buffer{}
-	bodywriter := multipart.NewWriter(body)
-
-	if len(content) != 0 {
-		if err := bodywriter.WriteField("content", content); err != nil {
-			return nil, err
-		}
-	}
-
-	writer, err := bodywriter.CreateFormFile("file", name)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = io.Copy(writer, r)
-	if err != nil {
-		return
-	}
-
-	err = bodywriter.Close()
-	if err != nil {
-		return
-	}
-
-	response, err := s.request("POST", EndpointChannelMessages(channelID), bodywriter.FormDataContentType(), body.Bytes(), EndpointChannelMessages(channelID), 0)
-	if err != nil {
-		return
-	}
-
-	err = unmarshal(response, &st)
-	return
+func (s *Session) ChannelFileSendWithMessage(channelID, content string, name string, r io.Reader) (*Message, error) {
+	return s.ChannelMessageSendComplex(channelID, &MessageSend{File: &File{Name: name, Reader: r}, Content: content})
 }

 // ChannelInvites returns an array of Invite structures for the given channel
@ -1563,7 +1657,7 @@ func (s *Session) VoiceICE() (st *VoiceICE, err error) {
 // Functions specific to Discord Websockets
 // ------------------------------------------------------------------------------------------------

-// Gateway returns the a websocket Gateway address
+// Gateway returns the websocket Gateway address
 func (s *Session) Gateway() (gateway string, err error) {

 	response, err := s.RequestWithBucketID("GET", EndpointGateway, nil, EndpointGateway)
@ -1808,6 +1902,20 @@ func (s *Session) MessageReactions(channelID, messageID, emojiID string, limit i
 	return
 }

+// ------------------------------------------------------------------------------------------------
+// Functions specific to user notes
+// ------------------------------------------------------------------------------------------------
+
+// UserNoteSet sets the note for a specific user.
+func (s *Session) UserNoteSet(userID string, message string) (err error) {
+	data := struct {
+		Note string `json:"note"`
+	}{message}
+
+	_, err = s.RequestWithBucketID("PUT", EndpointUserNotes(userID), data, EndpointUserNotes(""))
+	return
+}
+
 // ------------------------------------------------------------------------------------------------
 // Functions specific to Discord Relationships (Friends list)
 // ------------------------------------------------------------------------------------------------
--- a/vendor/github.com/bwmarrin/discordgo/state.go
+++ b/vendor/github.com/bwmarrin/discordgo/state.go
@ -14,11 +14,16 @@ package discordgo

 import (
 	"errors"
+	"sort"
 	"sync"
 )

 // ErrNilState is returned when the state is nil.
-var ErrNilState = errors.New("State not instantiated, please use discordgo.New() or assign Session.State.")
+var ErrNilState = errors.New("state not instantiated, please use discordgo.New() or assign Session.State")
+
+// ErrStateNotFound is returned when the state cache
+// requested is not found
+var ErrStateNotFound = errors.New("state cache not found")

 // A State contains the current known state.
 // As discord sends this in a READY blob, it seems reasonable to simply
@ -33,6 +38,7 @@ type State struct {
 	TrackMembers    bool
 	TrackRoles      bool
 	TrackVoice      bool
+	TrackPresences  bool

 	guildMap   map[string]*Guild
 	channelMap map[string]*Channel
@ -45,13 +51,14 @@ func NewState() *State {
 			PrivateChannels: []*Channel{},
 			Guilds:          []*Guild{},
 		},
-		TrackChannels: true,
-		TrackEmojis:   true,
-		TrackMembers:  true,
-		TrackRoles:    true,
-		TrackVoice:    true,
-		guildMap:      make(map[string]*Guild),
-		channelMap:    make(map[string]*Channel),
+		TrackChannels:  true,
+		TrackEmojis:    true,
+		TrackMembers:   true,
+		TrackRoles:     true,
+		TrackVoice:     true,
+		TrackPresences: true,
+		guildMap:       make(map[string]*Guild),
+		channelMap:     make(map[string]*Channel),
 	}
 }

@ -143,7 +150,108 @@ func (s *State) Guild(guildID string) (*Guild, error) {
 		return g, nil
 	}

-	return nil, errors.New("Guild not found.")
+	return nil, ErrStateNotFound
+}
+
+// PresenceAdd adds a presence to the current world state, or
+// updates it if it already exists.
+func (s *State) PresenceAdd(guildID string, presence *Presence) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, p := range guild.Presences {
+		if p.User.ID == presence.User.ID {
+			//guild.Presences[i] = presence
+
+			//Update status
+			guild.Presences[i].Game = presence.Game
+			guild.Presences[i].Roles = presence.Roles
+			if presence.Status != "" {
+				guild.Presences[i].Status = presence.Status
+			}
+			if presence.Nick != "" {
+				guild.Presences[i].Nick = presence.Nick
+			}
+
+			//Update the optionally sent user information
+			//ID Is a mandatory field so you should not need to check if it is empty
+			guild.Presences[i].User.ID = presence.User.ID
+
+			if presence.User.Avatar != "" {
+				guild.Presences[i].User.Avatar = presence.User.Avatar
+			}
+			if presence.User.Discriminator != "" {
+				guild.Presences[i].User.Discriminator = presence.User.Discriminator
+			}
+			if presence.User.Email != "" {
+				guild.Presences[i].User.Email = presence.User.Email
+			}
+			if presence.User.Token != "" {
+				guild.Presences[i].User.Token = presence.User.Token
+			}
+			if presence.User.Username != "" {
+				guild.Presences[i].User.Username = presence.User.Username
+			}
+
+			return nil
+		}
+	}
+
+	guild.Presences = append(guild.Presences, presence)
+	return nil
+}
+
+// PresenceRemove removes a presence from the current world state.
+func (s *State) PresenceRemove(guildID string, presence *Presence) error {
+	if s == nil {
+		return ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return err
+	}
+
+	s.Lock()
+	defer s.Unlock()
+
+	for i, p := range guild.Presences {
+		if p.User.ID == presence.User.ID {
+			guild.Presences = append(guild.Presences[:i], guild.Presences[i+1:]...)
+			return nil
+		}
+	}
+
+	return ErrStateNotFound
+}
+
+// Presence gets a presence by ID from a guild.
+func (s *State) Presence(guildID, userID string) (*Presence, error) {
+	if s == nil {
+		return nil, ErrNilState
+	}
+
+	guild, err := s.Guild(guildID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, p := range guild.Presences {
+		if p.User.ID == userID {
+			return p, nil
+		}
+	}
+
+	return nil, ErrStateNotFound
 }

 // TODO: Consider moving Guild state update methods onto *Guild.
@ -195,7 +303,7 @@ func (s *State) MemberRemove(member *Member) error {
 		}
 	}

-	return errors.New("Member not found.")
+	return ErrStateNotFound
 }

 // Member gets a member by ID from a guild.
@ -218,7 +326,7 @@ func (s *State) Member(guildID, userID string) (*Member, error) {
 		}
 	}

-	return nil, errors.New("Member not found.")
+	return nil, ErrStateNotFound
 }

 // RoleAdd adds a role to the current world state, or
@ -268,7 +376,7 @@ func (s *State) RoleRemove(guildID, roleID string) error {
 		}
 	}

-	return errors.New("Role not found.")
+	return ErrStateNotFound
 }

 // Role gets a role by ID from a guild.
@ -291,10 +399,10 @@ func (s *State) Role(guildID, roleID string) (*Role, error) {
 		}
 	}

-	return nil, errors.New("Role not found.")
+	return nil, ErrStateNotFound
 }

-// ChannelAdd adds a guild to the current world state, or
+// ChannelAdd adds a channel to the current world state, or
 // updates it if it already exists.
 // Channels may exist either as PrivateChannels or inside
 // a guild.
@ -324,7 +432,7 @@ func (s *State) ChannelAdd(channel *Channel) error {
 	} else {
 		guild, ok := s.guildMap[channel.GuildID]
 		if !ok {
-			return errors.New("Guild for channel not found.")
+			return ErrStateNotFound
 		}

 		guild.Channels = append(guild.Channels, channel)
@ -403,7 +511,7 @@ func (s *State) Channel(channelID string) (*Channel, error) {
 		return c, nil
 	}

-	return nil, errors.New("Channel not found.")
+	return nil, ErrStateNotFound
 }

 // Emoji returns an emoji for a guild and emoji id.
@ -426,7 +534,7 @@ func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) {
 		}
 	}

-	return nil, errors.New("Emoji not found.")
+	return nil, ErrStateNotFound
 }

 // EmojiAdd adds an emoji to the current world state.
@ -523,7 +631,12 @@ func (s *State) MessageRemove(message *Message) error {
 		return ErrNilState
 	}

-	c, err := s.Channel(message.ChannelID)
+	return s.messageRemoveByID(message.ChannelID, message.ID)
+}
+
+// messageRemoveByID removes a message by channelID and messageID from the world state.
+func (s *State) messageRemoveByID(channelID, messageID string) error {
+	c, err := s.Channel(channelID)
 	if err != nil {
 		return err
 	}
@ -532,13 +645,13 @@ func (s *State) MessageRemove(message *Message) error {
 	defer s.Unlock()

 	for i, m := range c.Messages {
-		if m.ID == message.ID {
+		if m.ID == messageID {
 			c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
 			return nil
 		}
 	}

-	return errors.New("Message not found.")
+	return ErrStateNotFound
 }

 func (s *State) voiceStateUpdate(update *VoiceStateUpdate) error {
@ -592,7 +705,7 @@ func (s *State) Message(channelID, messageID string) (*Message, error) {
 		}
 	}

-	return nil, errors.New("Message not found.")
+	return nil, ErrStateNotFound
 }

 // OnReady takes a Ready event and updates all internal state.
@ -608,10 +721,9 @@ func (s *State) onReady(se *Session, r *Ready) (err error) {
 	// if state is disabled, store the bare essentials.
 	if !se.StateEnabled {
 		ready := Ready{
-			Version:           r.Version,
-			SessionID:         r.SessionID,
-			HeartbeatInterval: r.HeartbeatInterval,
-			User:              r.User,
+			Version:   r.Version,
+			SessionID: r.SessionID,
+			User:      r.User,
 		}

 		s.Ready = ready
@ -710,10 +822,55 @@ func (s *State) onInterface(se *Session, i interface{}) (err error) {
 		if s.MaxMessageCount != 0 {
 			err = s.MessageRemove(t.Message)
 		}
+	case *MessageDeleteBulk:
+		if s.MaxMessageCount != 0 {
+			for _, mID := range t.Messages {
+				s.messageRemoveByID(t.ChannelID, mID)
+			}
+		}
 	case *VoiceStateUpdate:
 		if s.TrackVoice {
 			err = s.voiceStateUpdate(t)
 		}
+	case *PresenceUpdate:
+		if s.TrackPresences {
+			s.PresenceAdd(t.GuildID, &t.Presence)
+		}
+		if s.TrackMembers {
+			if t.Status == StatusOffline {
+				return
+			}
+
+			var m *Member
+			m, err = s.Member(t.GuildID, t.User.ID)
+
+			if err != nil {
+				// Member not found; this is a user coming online
+				m = &Member{
+					GuildID: t.GuildID,
+					Nick:    t.Nick,
+					User:    t.User,
+					Roles:   t.Roles,
+				}
+
+			} else {
+
+				if t.Nick != "" {
+					m.Nick = t.Nick
+				}
+
+				if t.User.Username != "" {
+					m.User.Username = t.User.Username
+				}
+
+				// PresenceUpdates always contain a list of roles, so there's no need to check for an empty list here
+				m.Roles = t.Roles
+
+			}
+
+			err = s.MemberAdd(m)
+		}
+
 	}

 	return
@ -747,48 +904,46 @@ func (s *State) UserChannelPermissions(userID, channelID string) (apermissions i
 		return
 	}

-	for _, role := range guild.Roles {
-		if role.ID == guild.ID {
-			apermissions |= role.Permissions
-			break
-		}
+	return memberPermissions(guild, channel, member), nil
+}
+
+// UserColor returns the color of a user in a channel.
+// While colors are defined at a Guild level, determining for a channel is more useful in message handlers.
+// 0 is returned in cases of error, which is the color of @everyone.
+// userID    : The ID of the user to calculate the color for.
+// channelID   : The ID of the channel to calculate the color for.
+func (s *State) UserColor(userID, channelID string) int {
+	if s == nil {
+		return 0
 	}

-	for _, role := range guild.Roles {
+	channel, err := s.Channel(channelID)
+	if err != nil {
+		return 0
+	}
+
+	guild, err := s.Guild(channel.GuildID)
+	if err != nil {
+		return 0
+	}
+
+	member, err := s.Member(guild.ID, userID)
+	if err != nil {
+		return 0
+	}
+
+	roles := Roles(guild.Roles)
+	sort.Sort(roles)
+
+	for _, role := range roles {
 		for _, roleID := range member.Roles {
 			if role.ID == roleID {
-				apermissions |= role.Permissions
-				break
+				if role.Color != 0 {
+					return role.Color
+				}
 			}
 		}
 	}

-	if apermissions&PermissionAdministrator > 0 {
-		apermissions |= PermissionAll
-	}
-
-	// Member overwrites can override role overrides, so do two passes
-	for _, overwrite := range channel.PermissionOverwrites {
-		for _, roleID := range member.Roles {
-			if overwrite.Type == "role" && roleID == overwrite.ID {
-				apermissions &= ^overwrite.Deny
-				apermissions |= overwrite.Allow
-				break
-			}
-		}
-	}
-
-	for _, overwrite := range channel.PermissionOverwrites {
-		if overwrite.Type == "member" && overwrite.ID == userID {
-			apermissions &= ^overwrite.Deny
-			apermissions |= overwrite.Allow
-			break
-		}
-	}
-
-	if apermissions&PermissionAdministrator > 0 {
-		apermissions |= PermissionAllChannel
-	}
-
-	return
+	return 0
 }
--- a/vendor/github.com/bwmarrin/discordgo/structs.go
+++ b/vendor/github.com/bwmarrin/discordgo/structs.go
@ -13,6 +13,7 @@ package discordgo

 import (
 	"encoding/json"
+	"net/http"
 	"strconv"
 	"sync"
 	"time"
@ -28,6 +29,7 @@ type Session struct {

 	// Authentication token for this session
 	Token string
+	MFA   bool

 	// Debug for printing JSON request/responses
 	Debug    bool // Deprecated, will be removed.
@ -73,6 +75,9 @@ type Session struct {
 	// StateEnabled is true.
 	State *State

+	// The http client used for REST requests
+	Client *http.Client
+
 	// Event handlers
 	handlersMu   sync.RWMutex
 	handlers     map[string][]*eventHandlerInstance
@ -88,7 +93,7 @@ type Session struct {
 	ratelimiter *RateLimiter

 	// sequence tracks the current gateway api websocket sequence number
-	sequence int
+	sequence *int64

 	// stores sessions current Discord Gateway
 	gateway string
@ -100,12 +105,6 @@ type Session struct {
 	wsMutex sync.Mutex
 }

-type rateLimitMutex struct {
-	sync.Mutex
-	url map[string]*sync.Mutex
-	// bucket map[string]*sync.Mutex // TODO :)
-}
-
 // A VoiceRegion stores data for a specific voice region server.
 type VoiceRegion struct {
 	ID       string `json:"id"`
@ -235,9 +234,15 @@ type UserGuild struct {

 // A GuildParams stores all the data needed to update discord guild settings
 type GuildParams struct {
-	Name              string             `json:"name"`
-	Region            string             `json:"region"`
-	VerificationLevel *VerificationLevel `json:"verification_level"`
+	Name                        string             `json:"name,omitempty"`
+	Region                      string             `json:"region,omitempty"`
+	VerificationLevel           *VerificationLevel `json:"verification_level,omitempty"`
+	DefaultMessageNotifications int                `json:"default_message_notifications,omitempty"` // TODO: Separate type?
+	AfkChannelID                string             `json:"afk_channel_id,omitempty"`
+	AfkTimeout                  int                `json:"afk_timeout,omitempty"`
+	Icon                        string             `json:"icon,omitempty"`
+	OwnerID                     string             `json:"owner_id,omitempty"`
+	Splash                      string             `json:"splash,omitempty"`
 }

 // A Role stores information about Discord guild member roles.
@ -252,6 +257,21 @@ type Role struct {
 	Permissions int    `json:"permissions"`
 }

+// Roles are a collection of Role
+type Roles []*Role
+
+func (r Roles) Len() int {
+	return len(r)
+}
+
+func (r Roles) Less(i, j int) bool {
+	return r[i].Position > r[j].Position
+}
+
+func (r Roles) Swap(i, j int) {
+	r[i], r[j] = r[j], r[i]
+}
+
 // A VoiceState stores the voice states of Guilds
 type VoiceState struct {
 	UserID    string `json:"user_id"`
@ -284,7 +304,7 @@ type Game struct {
 // UnmarshalJSON unmarshals json to Game struct
 func (g *Game) UnmarshalJSON(bytes []byte) error {
 	temp := &struct {
-		Name string          `json:"name"`
+		Name json.Number     `json:"name"`
 		Type json.RawMessage `json:"type"`
 		URL  string          `json:"url"`
 	}{}
@ -292,8 +312,8 @@ func (g *Game) UnmarshalJSON(bytes []byte) error {
 	if err != nil {
 		return err
 	}
-	g.Name = temp.Name
 	g.URL = temp.URL
+	g.Name = temp.Name.String()

 	if temp.Type != nil {
 		err = json.Unmarshal(temp.Type, &g.Type)
@ -324,19 +344,6 @@ type Member struct {
 	Roles    []string `json:"roles"`
 }

-// A User stores all data for an individual Discord user.
-type User struct {
-	ID            string `json:"id"`
-	Email         string `json:"email"`
-	Username      string `json:"username"`
-	Avatar        string `json:"Avatar"`
-	Discriminator string `json:"discriminator"`
-	Token         string `json:"token"`
-	Verified      bool   `json:"verified"`
-	MFAEnabled    bool   `json:"mfa_enabled"`
-	Bot           bool   `json:"bot"`
-}
-
 // A Settings stores data for a specific users Discord client settings.
 type Settings struct {
 	RenderEmbeds           bool               `json:"render_embeds"`
@ -542,6 +549,8 @@ const (
 	PermissionAdministrator
 	PermissionManageChannels
 	PermissionManageServer
+	PermissionAddReactions
+	PermissionViewAuditLogs

 	PermissionAllText = PermissionReadMessages |
 		PermissionSendMessages |
@ -561,9 +570,12 @@ const (
 		PermissionAllVoice |
 		PermissionCreateInstantInvite |
 		PermissionManageRoles |
-		PermissionManageChannels
+		PermissionManageChannels |
+		PermissionAddReactions |
+		PermissionViewAuditLogs
 	PermissionAll = PermissionAllChannel |
 		PermissionKickMembers |
 		PermissionBanMembers |
-		PermissionManageServer
+		PermissionManageServer |
+		PermissionAdministrator
 )
--- a/vendor/github.com/bwmarrin/discordgo/tools/cmd/eventhandlers/main.go
+++ b/vendor/github.com/bwmarrin/discordgo/tools/cmd/eventhandlers/main.go
@ -37,18 +37,18 @@ type {{privateName .}}EventHandler func(*Session, *{{.}})
 func (eh {{privateName .}}EventHandler) Type() string {
  return {{privateName .}}EventType
 }
-
+{{if isDiscordEvent .}}
 // New returns a new instance of {{.}}.
 func (eh {{privateName .}}EventHandler) New() interface{} {
  return &{{.}}{}
-}
-
+}{{end}}
 // Handle is the handler for {{.}} events.
 func (eh {{privateName .}}EventHandler) Handle(s *Session, i interface{}) {
  if t, ok := i.(*{{.}}); ok {
    eh(s, t)
  }
 }
+
 {{end}}
 func handlerForInterface(handler interface{}) EventHandler {
  switch v := handler.(type) {
@ -60,6 +60,7 @@ func handlerForInterface(handler interface{}) EventHandler {

  return nil
 }
+
 func init() { {{range .}}{{if isDiscordEvent .}}
  registerInterfaceProvider({{privateName .}}EventHandler(nil)){{end}}{{end}}
 }
--- a/vendor/github.com/bwmarrin/discordgo/user.go
+++ b/vendor/github.com/bwmarrin/discordgo/user.go
@ -0,0 +1,26 @@
+package discordgo
+
+import "fmt"
+
+// A User stores all data for an individual Discord user.
+type User struct {
+	ID            string `json:"id"`
+	Email         string `json:"email"`
+	Username      string `json:"username"`
+	Avatar        string `json:"avatar"`
+	Discriminator string `json:"discriminator"`
+	Token         string `json:"token"`
+	Verified      bool   `json:"verified"`
+	MFAEnabled    bool   `json:"mfa_enabled"`
+	Bot           bool   `json:"bot"`
+}
+
+// String returns a unique identifier of the form username#discriminator
+func (u *User) String() string {
+	return fmt.Sprintf("%s#%s", u.Username, u.Discriminator)
+}
+
+// Mention return a string which mentions the user
+func (u *User) Mention() string {
+	return fmt.Sprintf("<@%s>", u.ID)
+}
--- a/vendor/github.com/bwmarrin/discordgo/voice.go
+++ b/vendor/github.com/bwmarrin/discordgo/voice.go
@ -15,7 +15,6 @@ import (
 	"fmt"
 	"log"
 	"net"
-	"runtime"
 	"strings"
 	"sync"
 	"time"
@ -93,18 +92,22 @@ func (v *VoiceConnection) Speaking(b bool) (err error) {
 	}

 	if v.wsConn == nil {
-		return fmt.Errorf("No VoiceConnection websocket.")
+		return fmt.Errorf("no VoiceConnection websocket")
 	}

 	data := voiceSpeakingOp{5, voiceSpeakingData{b, 0}}
 	v.wsMutex.Lock()
 	err = v.wsConn.WriteJSON(data)
 	v.wsMutex.Unlock()
+
+	v.Lock()
+	defer v.Unlock()
 	if err != nil {
 		v.speaking = false
 		log.Println("Speaking() write json error:", err)
 		return
 	}
+
 	v.speaking = b

 	return
@ -139,9 +142,9 @@ func (v *VoiceConnection) Disconnect() (err error) {
 	// Send a OP4 with a nil channel to disconnect
 	if v.sessionID != "" {
 		data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
-		v.wsMutex.Lock()
+		v.session.wsMutex.Lock()
 		err = v.session.wsConn.WriteJSON(data)
-		v.wsMutex.Unlock()
+		v.session.wsMutex.Unlock()
 		v.sessionID = ""
 	}

@ -149,7 +152,10 @@ func (v *VoiceConnection) Disconnect() (err error) {
 	v.Close()

 	v.log(LogInformational, "Deleting VoiceConnection %s", v.GuildID)
+
+	v.session.Lock()
 	delete(v.session.VoiceConnections, v.GuildID)
+	v.session.Unlock()

 	return
 }
@ -185,7 +191,9 @@ func (v *VoiceConnection) Close() {

 		// To cleanly close a connection, a client should send a close
 		// frame and wait for the server to close the connection.
+		v.wsMutex.Lock()
 		err := v.wsConn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+		v.wsMutex.Unlock()
 		if err != nil {
 			v.log(LogError, "error closing websocket, %s", err)
 		}
@ -246,12 +254,15 @@ func (v *VoiceConnection) waitUntilConnected() error {

 	i := 0
 	for {
-		if v.Ready {
+		v.RLock()
+		ready := v.Ready
+		v.RUnlock()
+		if ready {
 			return nil
 		}

 		if i > 10 {
-			return fmt.Errorf("Timeout waiting for voice.")
+			return fmt.Errorf("timeout waiting for voice")
 		}

 		time.Sleep(1 * time.Second)
@ -282,7 +293,7 @@ func (v *VoiceConnection) open() (err error) {
 			break
 		}
 		if i > 20 { // only loop for up to 1 second total
-			return fmt.Errorf("Did not receive voice Session ID in time.")
+			return fmt.Errorf("did not receive voice Session ID in time")
 		}
 		time.Sleep(50 * time.Millisecond)
 		i++
@ -409,8 +420,6 @@ func (v *VoiceConnection) onEvent(message []byte) {
 			go v.opusReceiver(v.udpConn, v.close, v.OpusRecv)
 		}

-		// Send the ready event
-		v.connected <- true
 		return

 	case 3: // HEARTBEAT response
@ -418,6 +427,9 @@ func (v *VoiceConnection) onEvent(message []byte) {
 		return

 	case 4: // udp encryption secret key
+		v.Lock()
+		defer v.Unlock()
+
 		v.op4 = voiceOP4{}
 		if err := json.Unmarshal(e.RawData, &v.op4); err != nil {
 			v.log(LogError, "OP4 unmarshall error, %s, %s", err, string(e.RawData))
@ -466,6 +478,7 @@ func (v *VoiceConnection) wsHeartbeat(wsConn *websocket.Conn, close <-chan struc

 	var err error
 	ticker := time.NewTicker(i * time.Millisecond)
+	defer ticker.Stop()
 	for {
 		v.log(LogDebug, "sending heartbeat packet")
 		v.wsMutex.Lock()
@ -616,6 +629,7 @@ func (v *VoiceConnection) udpKeepAlive(udpConn *net.UDPConn, close <-chan struct
 	packet := make([]byte, 8)

 	ticker := time.NewTicker(i)
+	defer ticker.Stop()
 	for {

 		binary.LittleEndian.PutUint64(packet, sequence)
@ -644,12 +658,16 @@ func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}
 		return
 	}

-	runtime.LockOSThread()
-
 	// VoiceConnection is now ready to receive audio packets
 	// TODO: this needs reviewed as I think there must be a better way.
+	v.Lock()
 	v.Ready = true
-	defer func() { v.Ready = false }()
+	v.Unlock()
+	defer func() {
+		v.Lock()
+		v.Ready = false
+		v.Unlock()
+	}()

 	var sequence uint16
 	var timestamp uint32
@ -665,6 +683,7 @@ func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}

 	// start a send loop that loops until buf chan is closed
 	ticker := time.NewTicker(time.Millisecond * time.Duration(size/(rate/1000)))
+	defer ticker.Stop()
 	for {

 		// Get data from chan.  If chan is closed, return.
@ -678,7 +697,10 @@ func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}
 			// else, continue loop
 		}

-		if !v.speaking {
+		v.RLock()
+		speaking := v.speaking
+		v.RUnlock()
+		if !speaking {
 			err := v.Speaking(true)
 			if err != nil {
 				v.log(LogError, "error sending speaking packet, %s", err)
@ -691,7 +713,9 @@ func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}

 		// encrypt the opus data
 		copy(nonce[:], udpHeader)
+		v.RLock()
 		sendbuf := secretbox.Seal(udpHeader, recvbuf, &nonce, &v.op4.SecretKey)
+		v.RUnlock()

 		// block here until we're exactly at the right time :)
 		// Then send rtp audio packet to Discord over UDP
@ -742,7 +766,6 @@ func (v *VoiceConnection) opusReceiver(udpConn *net.UDPConn, close <-chan struct
 		return
 	}

-	p := Packet{}
 	recvbuf := make([]byte, 1024)
 	var nonce [24]byte

@ -778,6 +801,7 @@ func (v *VoiceConnection) opusReceiver(udpConn *net.UDPConn, close <-chan struct
 		}

 		// build a audio packet struct
+		p := Packet{}
 		p.Type = recvbuf[0:2]
 		p.Sequence = binary.BigEndian.Uint16(recvbuf[2:4])
 		p.Timestamp = binary.BigEndian.Uint32(recvbuf[4:8])
@ -837,6 +861,8 @@ func (v *VoiceConnection) reconnect() {
 			return
 		}

+		v.log(LogInformational, "error reconnecting to channel %s, %s", v.ChannelID, err)
+
 		// if the reconnect above didn't work lets just send a disconnect
 		// packet to reset things.
 		// Send a OP4 with a nil channel to disconnect
@ -848,6 +874,5 @@ func (v *VoiceConnection) reconnect() {
 			v.log(LogError, "error sending disconnect packet, %s", err)
 		}

-		v.log(LogInformational, "error reconnecting to channel %s, %s", v.ChannelID, err)
 	}
 }
--- a/vendor/github.com/bwmarrin/discordgo/wsapi.go
+++ b/vendor/github.com/bwmarrin/discordgo/wsapi.go
@ -19,17 +19,30 @@ import (
 	"io"
 	"net/http"
 	"runtime"
+	"sync/atomic"
 	"time"

 	"github.com/gorilla/websocket"
 )

+// ErrWSAlreadyOpen is thrown when you attempt to open
+// a websocket that already is open.
+var ErrWSAlreadyOpen = errors.New("web socket already opened")
+
+// ErrWSNotFound is thrown when you attempt to use a websocket
+// that doesn't exist
+var ErrWSNotFound = errors.New("no websocket connection exists")
+
+// ErrWSShardBounds is thrown when you try to use a shard ID that is
+// less than the total shard count
+var ErrWSShardBounds = errors.New("ShardID must be less than ShardCount")
+
 type resumePacket struct {
 	Op   int `json:"op"`
 	Data struct {
 		Token     string `json:"token"`
 		SessionID string `json:"session_id"`
-		Sequence  int    `json:"seq"`
+		Sequence  int64  `json:"seq"`
 	} `json:"d"`
 }

@ -57,7 +70,7 @@ func (s *Session) Open() (err error) {
 	}

 	if s.wsConn != nil {
-		err = errors.New("Web socket already opened.")
+		err = ErrWSAlreadyOpen
 		return
 	}

@ -74,7 +87,7 @@ func (s *Session) Open() (err error) {
 		}

 		// Add the version and encoding to the URL
-		s.gateway = fmt.Sprintf("%s?v=4&encoding=json", s.gateway)
+		s.gateway = fmt.Sprintf("%s?v=5&encoding=json", s.gateway)
 	}

 	header := http.Header{}
@ -89,13 +102,14 @@ func (s *Session) Open() (err error) {
 		return
 	}

-	if s.sessionID != "" && s.sequence > 0 {
+	sequence := atomic.LoadInt64(s.sequence)
+	if s.sessionID != "" && sequence > 0 {

 		p := resumePacket{}
 		p.Op = 6
 		p.Data.Token = s.Token
 		p.Data.SessionID = s.sessionID
-		p.Data.Sequence = s.sequence
+		p.Data.Sequence = sequence

 		s.log(LogInformational, "sending resume packet to gateway")
 		err = s.wsConn.WriteJSON(p)
@ -176,8 +190,13 @@ func (s *Session) listen(wsConn *websocket.Conn, listening <-chan interface{}) {
 }

 type heartbeatOp struct {
-	Op   int `json:"op"`
-	Data int `json:"d"`
+	Op   int   `json:"op"`
+	Data int64 `json:"d"`
+}
+
+type helloOp struct {
+	HeartbeatInterval time.Duration `json:"heartbeat_interval"`
+	Trace             []string      `json:"_trace"`
 }

 // heartbeat sends regular heartbeats to Discord so it knows the client
@ -193,12 +212,13 @@ func (s *Session) heartbeat(wsConn *websocket.Conn, listening <-chan interface{}

 	var err error
 	ticker := time.NewTicker(i * time.Millisecond)
+	defer ticker.Stop()

 	for {
-
-		s.log(LogInformational, "sending gateway websocket heartbeat seq %d", s.sequence)
+		sequence := atomic.LoadInt64(s.sequence)
+		s.log(LogInformational, "sending gateway websocket heartbeat seq %d", sequence)
 		s.wsMutex.Lock()
-		err = wsConn.WriteJSON(heartbeatOp{1, s.sequence})
+		err = wsConn.WriteJSON(heartbeatOp{1, sequence})
 		s.wsMutex.Unlock()
 		if err != nil {
 			s.log(LogError, "error sending heartbeat to gateway %s, %s", s.gateway, err)
@ -242,7 +262,7 @@ func (s *Session) UpdateStreamingStatus(idle int, game string, url string) (err
 	s.RLock()
 	defer s.RUnlock()
 	if s.wsConn == nil {
-		return errors.New("no websocket connection exists")
+		return ErrWSNotFound
 	}

 	var usd updateStatusData
@ -299,7 +319,7 @@ func (s *Session) RequestGuildMembers(guildID, query string, limit int) (err err
 	s.RLock()
 	defer s.RUnlock()
 	if s.wsConn == nil {
-		return errors.New("no websocket connection exists")
+		return ErrWSNotFound
 	}

 	data := requestGuildMembersData{
@ -365,7 +385,7 @@ func (s *Session) onEvent(messageType int, message []byte) {
 	if e.Operation == 1 {
 		s.log(LogInformational, "sending heartbeat in response to Op1")
 		s.wsMutex.Lock()
-		err = s.wsConn.WriteJSON(heartbeatOp{1, s.sequence})
+		err = s.wsConn.WriteJSON(heartbeatOp{1, atomic.LoadInt64(s.sequence)})
 		s.wsMutex.Unlock()
 		if err != nil {
 			s.log(LogError, "error sending heartbeat in response to Op1")
@ -396,6 +416,16 @@ func (s *Session) onEvent(messageType int, message []byte) {
 		return
 	}

+	if e.Operation == 10 {
+		var h helloOp
+		if err = json.Unmarshal(e.RawData, &h); err != nil {
+			s.log(LogError, "error unmarshalling helloOp, %s", err)
+		} else {
+			go s.heartbeat(s.wsConn, s.listening, h.HeartbeatInterval)
+		}
+		return
+	}
+
 	// Do not try to Dispatch a non-Dispatch Message
 	if e.Operation != 0 {
 		// But we probably should be doing something with them.
@ -405,7 +435,7 @@ func (s *Session) onEvent(messageType int, message []byte) {
 	}

 	// Store the message sequence
-	s.sequence = e.Sequence
+	atomic.StoreInt64(s.sequence, e.Sequence)

 	// Map event to registered event handlers and pass it along to any registered handlers.
 	if eh, ok := registeredInterfaceProviders[e.Type]; ok {
@ -458,18 +488,24 @@ func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (voice *Voi

 	s.log(LogInformational, "called")

+	s.RLock()
 	voice, _ = s.VoiceConnections[gID]
+	s.RUnlock()

 	if voice == nil {
 		voice = &VoiceConnection{}
+		s.Lock()
 		s.VoiceConnections[gID] = voice
+		s.Unlock()
 	}

+	voice.Lock()
 	voice.GuildID = gID
 	voice.ChannelID = cID
 	voice.deaf = deaf
 	voice.mute = mute
 	voice.session = s
+	voice.Unlock()

 	// Send the request to Discord that we want to join the voice channel
 	data := voiceChannelJoinOp{4, voiceChannelJoinData{&gID, &cID, mute, deaf}}
@ -500,7 +536,9 @@ func (s *Session) onVoiceStateUpdate(st *VoiceStateUpdate) {
 	}

 	// Check if we have a voice connection to update
+	s.RLock()
 	voice, exists := s.VoiceConnections[st.GuildID]
+	s.RUnlock()
 	if !exists {
 		return
 	}
@ -511,8 +549,11 @@ func (s *Session) onVoiceStateUpdate(st *VoiceStateUpdate) {
 	}

 	// Store the SessionID for later use.
+	voice.Lock()
 	voice.UserID = st.UserID
 	voice.sessionID = st.SessionID
+	voice.ChannelID = st.ChannelID
+	voice.Unlock()
 }

 // onVoiceServerUpdate handles the Voice Server Update data websocket event.
@ -524,7 +565,9 @@ func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {

 	s.log(LogInformational, "called")

+	s.RLock()
 	voice, exists := s.VoiceConnections[st.GuildID]
+	s.RUnlock()

 	// If no VoiceConnection exists, just skip this
 	if !exists {
@ -536,9 +579,11 @@ func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
 	voice.Close()

 	// Store values for later use
+	voice.Lock()
 	voice.token = st.Token
 	voice.endpoint = st.Endpoint
 	voice.GuildID = st.GuildID
+	voice.Unlock()

 	// Open a conenction to the voice server
 	err := voice.open()
@ -588,7 +633,7 @@ func (s *Session) identify() error {
 	if s.ShardCount > 1 {

 		if s.ShardID >= s.ShardCount {
-			return errors.New("ShardID must be less than ShardCount")
+			return ErrWSShardBounds
 		}

 		data.Shard = &[2]int{s.ShardID, s.ShardCount}
@ -628,6 +673,8 @@ func (s *Session) reconnect() {
 				// However, there seems to be cases where something "weird"
 				// happens.  So we're doing this for now just to improve
 				// stability in those edge cases.
+				s.RLock()
+				defer s.RUnlock()
 				for _, v := range s.VoiceConnections {

 					s.log(LogInformational, "reconnecting voice connection to guild %s", v.GuildID)
@ -675,7 +722,9 @@ func (s *Session) Close() (err error) {
 		s.log(LogInformational, "sending close frame")
 		// To cleanly close a connection, a client should send a close
 		// frame and wait for the server to close the connection.
+		s.wsMutex.Lock()
 		err := s.wsConn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+		s.wsMutex.Unlock()
 		if err != nil {
 			s.log(LogInformational, "error closing websocket, %s", err)
 		}
--- a/vendor/github.com/hashicorp/golang-lru/2q.go
+++ b/vendor/github.com/hashicorp/golang-lru/2q.go
@ -0,0 +1,212 @@
+package lru
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/hashicorp/golang-lru/simplelru"
+)
+
+const (
+	// Default2QRecentRatio is the ratio of the 2Q cache dedicated
+	// to recently added entries that have only been accessed once.
+	Default2QRecentRatio = 0.25
+
+	// Default2QGhostEntries is the default ratio of ghost
+	// entries kept to track entries recently evicted
+	Default2QGhostEntries = 0.50
+)
+
+// TwoQueueCache is a thread-safe fixed size 2Q cache.
+// 2Q is an enhancement over the standard LRU cache
+// in that it tracks both frequently and recently used
+// entries separately. This avoids a burst in access to new
+// entries from evicting frequently used entries. It adds some
+// additional tracking overhead to the standard LRU cache, and is
+// computationally about 2x the cost, and adds some metadata over
+// head. The ARCCache is similar, but does not require setting any
+// parameters.
+type TwoQueueCache struct {
+	size       int
+	recentSize int
+
+	recent      *simplelru.LRU
+	frequent    *simplelru.LRU
+	recentEvict *simplelru.LRU
+	lock        sync.RWMutex
+}
+
+// New2Q creates a new TwoQueueCache using the default
+// values for the parameters.
+func New2Q(size int) (*TwoQueueCache, error) {
+	return New2QParams(size, Default2QRecentRatio, Default2QGhostEntries)
+}
+
+// New2QParams creates a new TwoQueueCache using the provided
+// parameter values.
+func New2QParams(size int, recentRatio float64, ghostRatio float64) (*TwoQueueCache, error) {
+	if size <= 0 {
+		return nil, fmt.Errorf("invalid size")
+	}
+	if recentRatio < 0.0 || recentRatio > 1.0 {
+		return nil, fmt.Errorf("invalid recent ratio")
+	}
+	if ghostRatio < 0.0 || ghostRatio > 1.0 {
+		return nil, fmt.Errorf("invalid ghost ratio")
+	}
+
+	// Determine the sub-sizes
+	recentSize := int(float64(size) * recentRatio)
+	evictSize := int(float64(size) * ghostRatio)
+
+	// Allocate the LRUs
+	recent, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+	frequent, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+	recentEvict, err := simplelru.NewLRU(evictSize, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize the cache
+	c := &TwoQueueCache{
+		size:        size,
+		recentSize:  recentSize,
+		recent:      recent,
+		frequent:    frequent,
+		recentEvict: recentEvict,
+	}
+	return c, nil
+}
+
+func (c *TwoQueueCache) Get(key interface{}) (interface{}, bool) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Check if this is a frequent value
+	if val, ok := c.frequent.Get(key); ok {
+		return val, ok
+	}
+
+	// If the value is contained in recent, then we
+	// promote it to frequent
+	if val, ok := c.recent.Peek(key); ok {
+		c.recent.Remove(key)
+		c.frequent.Add(key, val)
+		return val, ok
+	}
+
+	// No hit
+	return nil, false
+}
+
+func (c *TwoQueueCache) Add(key, value interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Check if the value is frequently used already,
+	// and just update the value
+	if c.frequent.Contains(key) {
+		c.frequent.Add(key, value)
+		return
+	}
+
+	// Check if the value is recently used, and promote
+	// the value into the frequent list
+	if c.recent.Contains(key) {
+		c.recent.Remove(key)
+		c.frequent.Add(key, value)
+		return
+	}
+
+	// If the value was recently evicted, add it to the
+	// frequently used list
+	if c.recentEvict.Contains(key) {
+		c.ensureSpace(true)
+		c.recentEvict.Remove(key)
+		c.frequent.Add(key, value)
+		return
+	}
+
+	// Add to the recently seen list
+	c.ensureSpace(false)
+	c.recent.Add(key, value)
+	return
+}
+
+// ensureSpace is used to ensure we have space in the cache
+func (c *TwoQueueCache) ensureSpace(recentEvict bool) {
+	// If we have space, nothing to do
+	recentLen := c.recent.Len()
+	freqLen := c.frequent.Len()
+	if recentLen+freqLen < c.size {
+		return
+	}
+
+	// If the recent buffer is larger than
+	// the target, evict from there
+	if recentLen > 0 && (recentLen > c.recentSize || (recentLen == c.recentSize && !recentEvict)) {
+		k, _, _ := c.recent.RemoveOldest()
+		c.recentEvict.Add(k, nil)
+		return
+	}
+
+	// Remove from the frequent list otherwise
+	c.frequent.RemoveOldest()
+}
+
+func (c *TwoQueueCache) Len() int {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.recent.Len() + c.frequent.Len()
+}
+
+func (c *TwoQueueCache) Keys() []interface{} {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	k1 := c.frequent.Keys()
+	k2 := c.recent.Keys()
+	return append(k1, k2...)
+}
+
+func (c *TwoQueueCache) Remove(key interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if c.frequent.Remove(key) {
+		return
+	}
+	if c.recent.Remove(key) {
+		return
+	}
+	if c.recentEvict.Remove(key) {
+		return
+	}
+}
+
+func (c *TwoQueueCache) Purge() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	c.recent.Purge()
+	c.frequent.Purge()
+	c.recentEvict.Purge()
+}
+
+func (c *TwoQueueCache) Contains(key interface{}) bool {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.frequent.Contains(key) || c.recent.Contains(key)
+}
+
+func (c *TwoQueueCache) Peek(key interface{}) (interface{}, bool) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	if val, ok := c.frequent.Peek(key); ok {
+		return val, ok
+	}
+	return c.recent.Peek(key)
+}
--- a/vendor/github.com/hashicorp/golang-lru/LICENSE
+++ b/vendor/github.com/hashicorp/golang-lru/LICENSE
@ -0,0 +1,362 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. "Contributor"
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+
+     means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the terms of
+        a Secondary License.
+
+1.6. "Executable Form"
+
+     means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+
+     means a work that combines Covered Software with other material, in a
+     separate file or files, that is not Covered Software.
+
+1.8. "License"
+
+     means this document.
+
+1.9. "Licensable"
+
+     means having the right to grant, to the maximum extent possible, whether
+     at the time of the initial grant or subsequently, any and all of the
+     rights conveyed by this License.
+
+1.10. "Modifications"
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. "Patent Claims" of a Contributor
+
+      means any patent claim(s), including without limitation, method,
+      process, and apparatus claims, in any patent Licensable by such
+      Contributor that would be infringed, but for the grant of the License,
+      by the making, using, selling, offering for sale, having made, import,
+      or transfer of either its Contributions or its Contributor Version.
+
+1.12. "Secondary License"
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. "Source Code Form"
+
+      means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, "You" includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, "control" means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or
+        as part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its
+        Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution
+     become effective for each Contribution on the date the Contributor first
+     distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under
+     this License. No additional rights or licenses will be implied from the
+     distribution or licensing of Covered Software under this License.
+     Notwithstanding Section 2.1(b) above, no patent license is granted by a
+     Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party's
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of
+        its Contributions.
+
+     This License does not grant any rights in the trademarks, service marks,
+     or logos of any Contributor (except as may be necessary to comply with
+     the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this
+     License (see Section 10.2) or under the terms of a Secondary License (if
+     permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its
+     Contributions are its original creation(s) or it has sufficient rights to
+     grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under
+     applicable copyright doctrines of fair use, fair dealing, or other
+     equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under
+     the terms of this License. You must inform recipients that the Source
+     Code Form of the Covered Software is governed by the terms of this
+     License, and how they can obtain a copy of this License. You may not
+     attempt to alter or restrict the recipients' rights in the Source Code
+     Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this
+        License, or sublicense it under different terms, provided that the
+        license for the Executable Form does not attempt to limit or alter the
+        recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for
+     the Covered Software. If the Larger Work is a combination of Covered
+     Software with a work governed by one or more Secondary Licenses, and the
+     Covered Software is not Incompatible With Secondary Licenses, this
+     License permits You to additionally distribute such Covered Software
+     under the terms of such Secondary License(s), so that the recipient of
+     the Larger Work may, at their option, further distribute the Covered
+     Software under the terms of either this License or such Secondary
+     License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices
+     (including copyright notices, patent notices, disclaimers of warranty, or
+     limitations of liability) contained within the Source Code Form of the
+     Covered Software, except that You may alter any license notices to the
+     extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on
+     behalf of any Contributor. You must make it absolutely clear that any
+     such warranty, support, indemnity, or liability obligation is offered by
+     You alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute,
+   judicial order, or regulation then You must: (a) comply with the terms of
+   this License to the maximum extent possible; and (b) describe the
+   limitations and the code they affect. Such description must be placed in a
+   text file included with all distributions of the Covered Software under
+   this License. Except to the extent prohibited by statute or regulation,
+   such description must be sufficiently detailed for a recipient of ordinary
+   skill to be able to understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing
+     basis, if such Contributor fails to notify You of the non-compliance by
+     some reasonable means prior to 60 days after You have come back into
+     compliance. Moreover, Your grants from a particular Contributor are
+     reinstated on an ongoing basis if such Contributor notifies You of the
+     non-compliance by some reasonable means, this is the first time You have
+     received notice of non-compliance with this License from such
+     Contributor, and You become compliant prior to 30 days after Your receipt
+     of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions,
+     counter-claims, and cross-claims) alleging that a Contributor Version
+     directly or indirectly infringes any patent, then the rights granted to
+     You by any and all Contributors for the Covered Software under Section
+     2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an "as is" basis,
+   without warranty of any kind, either expressed, implied, or statutory,
+   including, without limitation, warranties that the Covered Software is free
+   of defects, merchantable, fit for a particular purpose or non-infringing.
+   The entire risk as to the quality and performance of the Covered Software
+   is with You. Should any Covered Software prove defective in any respect,
+   You (not any Contributor) assume the cost of any necessary servicing,
+   repair, or correction. This disclaimer of warranty constitutes an essential
+   part of this License. No use of  any Covered Software is authorized under
+   this License except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from
+   such party's negligence to the extent applicable law prohibits such
+   limitation. Some jurisdictions do not allow the exclusion or limitation of
+   incidental or consequential damages, so this exclusion and limitation may
+   not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts
+   of a jurisdiction where the defendant maintains its principal place of
+   business and such litigation shall be governed by laws of that
+   jurisdiction, without reference to its conflict-of-law provisions. Nothing
+   in this Section shall prevent a party's ability to bring cross-claims or
+   counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject
+   matter hereof. If any provision of this License is held to be
+   unenforceable, such provision shall be reformed only to the extent
+   necessary to make it enforceable. Any law or regulation which provides that
+   the language of a contract shall be construed against the drafter shall not
+   be used to construe this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version
+      of the License under which You originally received the Covered Software,
+      or under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a
+      modified version of this License if you rename the license and remove
+      any references to the name of the license steward (except to note that
+      such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+      Licenses If You choose to distribute Source Code Form that is
+      Incompatible With Secondary Licenses under the terms of this version of
+      the License, the notice described in Exhibit B of this License must be
+      attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file,
+then You may include the notice in a location (such as a LICENSE file in a
+relevant directory) where a recipient would be likely to look for such a
+notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+
+      This Source Code Form is "Incompatible
+      With Secondary Licenses", as defined by
+      the Mozilla Public License, v. 2.0.
--- a/vendor/github.com/hashicorp/golang-lru/arc.go
+++ b/vendor/github.com/hashicorp/golang-lru/arc.go
@ -0,0 +1,257 @@
+package lru
+
+import (
+	"sync"
+
+	"github.com/hashicorp/golang-lru/simplelru"
+)
+
+// ARCCache is a thread-safe fixed size Adaptive Replacement Cache (ARC).
+// ARC is an enhancement over the standard LRU cache in that tracks both
+// frequency and recency of use. This avoids a burst in access to new
+// entries from evicting the frequently used older entries. It adds some
+// additional tracking overhead to a standard LRU cache, computationally
+// it is roughly 2x the cost, and the extra memory overhead is linear
+// with the size of the cache. ARC has been patented by IBM, but is
+// similar to the TwoQueueCache (2Q) which requires setting parameters.
+type ARCCache struct {
+	size int // Size is the total capacity of the cache
+	p    int // P is the dynamic preference towards T1 or T2
+
+	t1 *simplelru.LRU // T1 is the LRU for recently accessed items
+	b1 *simplelru.LRU // B1 is the LRU for evictions from t1
+
+	t2 *simplelru.LRU // T2 is the LRU for frequently accessed items
+	b2 *simplelru.LRU // B2 is the LRU for evictions from t2
+
+	lock sync.RWMutex
+}
+
+// NewARC creates an ARC of the given size
+func NewARC(size int) (*ARCCache, error) {
+	// Create the sub LRUs
+	b1, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+	b2, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+	t1, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+	t2, err := simplelru.NewLRU(size, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// Initialize the ARC
+	c := &ARCCache{
+		size: size,
+		p:    0,
+		t1:   t1,
+		b1:   b1,
+		t2:   t2,
+		b2:   b2,
+	}
+	return c, nil
+}
+
+// Get looks up a key's value from the cache.
+func (c *ARCCache) Get(key interface{}) (interface{}, bool) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Ff the value is contained in T1 (recent), then
+	// promote it to T2 (frequent)
+	if val, ok := c.t1.Peek(key); ok {
+		c.t1.Remove(key)
+		c.t2.Add(key, val)
+		return val, ok
+	}
+
+	// Check if the value is contained in T2 (frequent)
+	if val, ok := c.t2.Get(key); ok {
+		return val, ok
+	}
+
+	// No hit
+	return nil, false
+}
+
+// Add adds a value to the cache.
+func (c *ARCCache) Add(key, value interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	// Check if the value is contained in T1 (recent), and potentially
+	// promote it to frequent T2
+	if c.t1.Contains(key) {
+		c.t1.Remove(key)
+		c.t2.Add(key, value)
+		return
+	}
+
+	// Check if the value is already in T2 (frequent) and update it
+	if c.t2.Contains(key) {
+		c.t2.Add(key, value)
+		return
+	}
+
+	// Check if this value was recently evicted as part of the
+	// recently used list
+	if c.b1.Contains(key) {
+		// T1 set is too small, increase P appropriately
+		delta := 1
+		b1Len := c.b1.Len()
+		b2Len := c.b2.Len()
+		if b2Len > b1Len {
+			delta = b2Len / b1Len
+		}
+		if c.p+delta >= c.size {
+			c.p = c.size
+		} else {
+			c.p += delta
+		}
+
+		// Potentially need to make room in the cache
+		if c.t1.Len()+c.t2.Len() >= c.size {
+			c.replace(false)
+		}
+
+		// Remove from B1
+		c.b1.Remove(key)
+
+		// Add the key to the frequently used list
+		c.t2.Add(key, value)
+		return
+	}
+
+	// Check if this value was recently evicted as part of the
+	// frequently used list
+	if c.b2.Contains(key) {
+		// T2 set is too small, decrease P appropriately
+		delta := 1
+		b1Len := c.b1.Len()
+		b2Len := c.b2.Len()
+		if b1Len > b2Len {
+			delta = b1Len / b2Len
+		}
+		if delta >= c.p {
+			c.p = 0
+		} else {
+			c.p -= delta
+		}
+
+		// Potentially need to make room in the cache
+		if c.t1.Len()+c.t2.Len() >= c.size {
+			c.replace(true)
+		}
+
+		// Remove from B2
+		c.b2.Remove(key)
+
+		// Add the key to the frequntly used list
+		c.t2.Add(key, value)
+		return
+	}
+
+	// Potentially need to make room in the cache
+	if c.t1.Len()+c.t2.Len() >= c.size {
+		c.replace(false)
+	}
+
+	// Keep the size of the ghost buffers trim
+	if c.b1.Len() > c.size-c.p {
+		c.b1.RemoveOldest()
+	}
+	if c.b2.Len() > c.p {
+		c.b2.RemoveOldest()
+	}
+
+	// Add to the recently seen list
+	c.t1.Add(key, value)
+	return
+}
+
+// replace is used to adaptively evict from either T1 or T2
+// based on the current learned value of P
+func (c *ARCCache) replace(b2ContainsKey bool) {
+	t1Len := c.t1.Len()
+	if t1Len > 0 && (t1Len > c.p || (t1Len == c.p && b2ContainsKey)) {
+		k, _, ok := c.t1.RemoveOldest()
+		if ok {
+			c.b1.Add(k, nil)
+		}
+	} else {
+		k, _, ok := c.t2.RemoveOldest()
+		if ok {
+			c.b2.Add(k, nil)
+		}
+	}
+}
+
+// Len returns the number of cached entries
+func (c *ARCCache) Len() int {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.t1.Len() + c.t2.Len()
+}
+
+// Keys returns all the cached keys
+func (c *ARCCache) Keys() []interface{} {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	k1 := c.t1.Keys()
+	k2 := c.t2.Keys()
+	return append(k1, k2...)
+}
+
+// Remove is used to purge a key from the cache
+func (c *ARCCache) Remove(key interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if c.t1.Remove(key) {
+		return
+	}
+	if c.t2.Remove(key) {
+		return
+	}
+	if c.b1.Remove(key) {
+		return
+	}
+	if c.b2.Remove(key) {
+		return
+	}
+}
+
+// Purge is used to clear the cache
+func (c *ARCCache) Purge() {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	c.t1.Purge()
+	c.t2.Purge()
+	c.b1.Purge()
+	c.b2.Purge()
+}
+
+// Contains is used to check if the cache contains a key
+// without updating recency or frequency.
+func (c *ARCCache) Contains(key interface{}) bool {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.t1.Contains(key) || c.t2.Contains(key)
+}
+
+// Peek is used to inspect the cache value of a key
+// without updating recency or frequency.
+func (c *ARCCache) Peek(key interface{}) (interface{}, bool) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	if val, ok := c.t1.Peek(key); ok {
+		return val, ok
+	}
+	return c.t2.Peek(key)
+}
--- a/vendor/github.com/hashicorp/golang-lru/lru.go
+++ b/vendor/github.com/hashicorp/golang-lru/lru.go
@ -0,0 +1,114 @@
+// This package provides a simple LRU cache. It is based on the
+// LRU implementation in groupcache:
+// https://github.com/golang/groupcache/tree/master/lru
+package lru
+
+import (
+	"sync"
+
+	"github.com/hashicorp/golang-lru/simplelru"
+)
+
+// Cache is a thread-safe fixed size LRU cache.
+type Cache struct {
+	lru  *simplelru.LRU
+	lock sync.RWMutex
+}
+
+// New creates an LRU of the given size
+func New(size int) (*Cache, error) {
+	return NewWithEvict(size, nil)
+}
+
+// NewWithEvict constructs a fixed size cache with the given eviction
+// callback.
+func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) (*Cache, error) {
+	lru, err := simplelru.NewLRU(size, simplelru.EvictCallback(onEvicted))
+	if err != nil {
+		return nil, err
+	}
+	c := &Cache{
+		lru: lru,
+	}
+	return c, nil
+}
+
+// Purge is used to completely clear the cache
+func (c *Cache) Purge() {
+	c.lock.Lock()
+	c.lru.Purge()
+	c.lock.Unlock()
+}
+
+// Add adds a value to the cache.  Returns true if an eviction occurred.
+func (c *Cache) Add(key, value interface{}) bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.lru.Add(key, value)
+}
+
+// Get looks up a key's value from the cache.
+func (c *Cache) Get(key interface{}) (interface{}, bool) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.lru.Get(key)
+}
+
+// Check if a key is in the cache, without updating the recent-ness
+// or deleting it for being stale.
+func (c *Cache) Contains(key interface{}) bool {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.lru.Contains(key)
+}
+
+// Returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *Cache) Peek(key interface{}) (interface{}, bool) {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.lru.Peek(key)
+}
+
+// ContainsOrAdd checks if a key is in the cache  without updating the
+// recent-ness or deleting it for being stale,  and if not, adds the value.
+// Returns whether found and whether an eviction occurred.
+func (c *Cache) ContainsOrAdd(key, value interface{}) (ok, evict bool) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	if c.lru.Contains(key) {
+		return true, false
+	} else {
+		evict := c.lru.Add(key, value)
+		return false, evict
+	}
+}
+
+// Remove removes the provided key from the cache.
+func (c *Cache) Remove(key interface{}) {
+	c.lock.Lock()
+	c.lru.Remove(key)
+	c.lock.Unlock()
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *Cache) RemoveOldest() {
+	c.lock.Lock()
+	c.lru.RemoveOldest()
+	c.lock.Unlock()
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *Cache) Keys() []interface{} {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.lru.Keys()
+}
+
+// Len returns the number of items in the cache.
+func (c *Cache) Len() int {
+	c.lock.RLock()
+	defer c.lock.RUnlock()
+	return c.lru.Len()
+}
--- a/vendor/github.com/hashicorp/golang-lru/simplelru/lru.go
+++ b/vendor/github.com/hashicorp/golang-lru/simplelru/lru.go
@ -0,0 +1,160 @@
+package simplelru
+
+import (
+	"container/list"
+	"errors"
+)
+
+// EvictCallback is used to get a callback when a cache entry is evicted
+type EvictCallback func(key interface{}, value interface{})
+
+// LRU implements a non-thread safe fixed size LRU cache
+type LRU struct {
+	size      int
+	evictList *list.List
+	items     map[interface{}]*list.Element
+	onEvict   EvictCallback
+}
+
+// entry is used to hold a value in the evictList
+type entry struct {
+	key   interface{}
+	value interface{}
+}
+
+// NewLRU constructs an LRU of the given size
+func NewLRU(size int, onEvict EvictCallback) (*LRU, error) {
+	if size <= 0 {
+		return nil, errors.New("Must provide a positive size")
+	}
+	c := &LRU{
+		size:      size,
+		evictList: list.New(),
+		items:     make(map[interface{}]*list.Element),
+		onEvict:   onEvict,
+	}
+	return c, nil
+}
+
+// Purge is used to completely clear the cache
+func (c *LRU) Purge() {
+	for k, v := range c.items {
+		if c.onEvict != nil {
+			c.onEvict(k, v.Value.(*entry).value)
+		}
+		delete(c.items, k)
+	}
+	c.evictList.Init()
+}
+
+// Add adds a value to the cache.  Returns true if an eviction occurred.
+func (c *LRU) Add(key, value interface{}) bool {
+	// Check for existing item
+	if ent, ok := c.items[key]; ok {
+		c.evictList.MoveToFront(ent)
+		ent.Value.(*entry).value = value
+		return false
+	}
+
+	// Add new item
+	ent := &entry{key, value}
+	entry := c.evictList.PushFront(ent)
+	c.items[key] = entry
+
+	evict := c.evictList.Len() > c.size
+	// Verify size not exceeded
+	if evict {
+		c.removeOldest()
+	}
+	return evict
+}
+
+// Get looks up a key's value from the cache.
+func (c *LRU) Get(key interface{}) (value interface{}, ok bool) {
+	if ent, ok := c.items[key]; ok {
+		c.evictList.MoveToFront(ent)
+		return ent.Value.(*entry).value, true
+	}
+	return
+}
+
+// Check if a key is in the cache, without updating the recent-ness
+// or deleting it for being stale.
+func (c *LRU) Contains(key interface{}) (ok bool) {
+	_, ok = c.items[key]
+	return ok
+}
+
+// Returns the key value (or undefined if not found) without updating
+// the "recently used"-ness of the key.
+func (c *LRU) Peek(key interface{}) (value interface{}, ok bool) {
+	if ent, ok := c.items[key]; ok {
+		return ent.Value.(*entry).value, true
+	}
+	return nil, ok
+}
+
+// Remove removes the provided key from the cache, returning if the
+// key was contained.
+func (c *LRU) Remove(key interface{}) bool {
+	if ent, ok := c.items[key]; ok {
+		c.removeElement(ent)
+		return true
+	}
+	return false
+}
+
+// RemoveOldest removes the oldest item from the cache.
+func (c *LRU) RemoveOldest() (interface{}, interface{}, bool) {
+	ent := c.evictList.Back()
+	if ent != nil {
+		c.removeElement(ent)
+		kv := ent.Value.(*entry)
+		return kv.key, kv.value, true
+	}
+	return nil, nil, false
+}
+
+// GetOldest returns the oldest entry
+func (c *LRU) GetOldest() (interface{}, interface{}, bool) {
+	ent := c.evictList.Back()
+	if ent != nil {
+		kv := ent.Value.(*entry)
+		return kv.key, kv.value, true
+	}
+	return nil, nil, false
+}
+
+// Keys returns a slice of the keys in the cache, from oldest to newest.
+func (c *LRU) Keys() []interface{} {
+	keys := make([]interface{}, len(c.items))
+	i := 0
+	for ent := c.evictList.Back(); ent != nil; ent = ent.Prev() {
+		keys[i] = ent.Value.(*entry).key
+		i++
+	}
+	return keys
+}
+
+// Len returns the number of items in the cache.
+func (c *LRU) Len() int {
+	return c.evictList.Len()
+}
+
+// removeOldest removes the oldest item from the cache.
+func (c *LRU) removeOldest() {
+	ent := c.evictList.Back()
+	if ent != nil {
+		c.removeElement(ent)
+	}
+}
+
+// removeElement is used to remove a given list element from the cache
+func (c *LRU) removeElement(e *list.Element) {
+	c.evictList.Remove(e)
+	kv := e.Value.(*entry)
+	delete(c.items, kv.key)
+	if c.onEvict != nil {
+		c.onEvict(kv.key, kv.value)
+	}
+}
--- a/vendor/github.com/nlopes/slack/admin.go
+++ b/vendor/github.com/nlopes/slack/admin.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"fmt"
 	"net/url"
@ -11,9 +12,9 @@ type adminResponse struct {
 	Error string `json:"error"`
 }

-func adminRequest(method string, teamName string, values url.Values, debug bool) (*adminResponse, error) {
+func adminRequest(ctx context.Context, method string, teamName string, values url.Values, debug bool) (*adminResponse, error) {
 	adminResponse := &adminResponse{}
-	err := parseAdminResponse(method, teamName, values, adminResponse, debug)
+	err := parseAdminResponse(ctx, method, teamName, values, adminResponse, debug)
 	if err != nil {
 		return nil, err
 	}
@ -27,6 +28,11 @@ func adminRequest(method string, teamName string, values url.Values, debug bool)

 // DisableUser disabled a user account, given a user ID
 func (api *Client) DisableUser(teamName string, uid string) error {
+	return api.DisableUserContext(context.Background(), teamName, uid)
+}
+
+// DisableUserContext disabled a user account, given a user ID with a custom context
+func (api *Client) DisableUserContext(ctx context.Context, teamName string, uid string) error {
 	values := url.Values{
 		"user":       {uid},
 		"token":      {api.config.token},
@ -34,7 +40,7 @@ func (api *Client) DisableUser(teamName string, uid string) error {
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("setInactive", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "setInactive", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to disable user with id '%s': %s", uid, err)
 	}
@ -43,13 +49,12 @@ func (api *Client) DisableUser(teamName string, uid string) error {
 }

 // InviteGuest invites a user to Slack as a single-channel guest
-func (api *Client) InviteGuest(
-	teamName string,
-	channel string,
-	firstName string,
-	lastName string,
-	emailAddress string,
-) error {
+func (api *Client) InviteGuest(teamName, channel, firstName, lastName, emailAddress string) error {
+	return api.InviteGuestContext(context.Background(), teamName, channel, firstName, lastName, emailAddress)
+}
+
+// InviteGuestContext invites a user to Slack as a single-channel guest with a custom context
+func (api *Client) InviteGuestContext(ctx context.Context, teamName, channel, firstName, lastName, emailAddress string) error {
 	values := url.Values{
 		"email":            {emailAddress},
 		"channels":         {channel},
@ -61,7 +66,7 @@ func (api *Client) InviteGuest(
 		"_attempts":        {"1"},
 	}

-	_, err := adminRequest("invite", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "invite", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to invite single-channel guest: %s", err)
 	}
@ -70,13 +75,12 @@ func (api *Client) InviteGuest(
 }

 // InviteRestricted invites a user to Slack as a restricted account
-func (api *Client) InviteRestricted(
-	teamName string,
-	channel string,
-	firstName string,
-	lastName string,
-	emailAddress string,
-) error {
+func (api *Client) InviteRestricted(teamName, channel, firstName, lastName, emailAddress string) error {
+	return api.InviteRestrictedContext(context.Background(), teamName, channel, firstName, lastName, emailAddress)
+}
+
+// InviteRestrictedContext invites a user to Slack as a restricted account with a custom context
+func (api *Client) InviteRestrictedContext(ctx context.Context, teamName, channel, firstName, lastName, emailAddress string) error {
 	values := url.Values{
 		"email":      {emailAddress},
 		"channels":   {channel},
@ -88,7 +92,7 @@ func (api *Client) InviteRestricted(
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("invite", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "invite", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to restricted account: %s", err)
 	}
@ -97,12 +101,12 @@ func (api *Client) InviteRestricted(
 }

 // InviteToTeam invites a user to a Slack team
-func (api *Client) InviteToTeam(
-	teamName string,
-	firstName string,
-	lastName string,
-	emailAddress string,
-) error {
+func (api *Client) InviteToTeam(teamName, firstName, lastName, emailAddress string) error {
+	return api.InviteToTeamContext(context.Background(), teamName, firstName, lastName, emailAddress)
+}
+
+// InviteToTeamContext invites a user to a Slack team with a custom context
+func (api *Client) InviteToTeamContext(ctx context.Context, teamName, firstName, lastName, emailAddress string) error {
 	values := url.Values{
 		"email":      {emailAddress},
 		"first_name": {firstName},
@ -112,7 +116,7 @@ func (api *Client) InviteToTeam(
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("invite", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "invite", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to invite to team: %s", err)
 	}
@ -121,7 +125,12 @@ func (api *Client) InviteToTeam(
 }

 // SetRegular enables the specified user
-func (api *Client) SetRegular(teamName string, user string) error {
+func (api *Client) SetRegular(teamName, user string) error {
+	return api.SetRegularContext(context.Background(), teamName, user)
+}
+
+// SetRegularContext enables the specified user with a custom context
+func (api *Client) SetRegularContext(ctx context.Context, teamName, user string) error {
 	values := url.Values{
 		"user":       {user},
 		"token":      {api.config.token},
@ -129,7 +138,7 @@ func (api *Client) SetRegular(teamName string, user string) error {
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("setRegular", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "setRegular", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to change the user (%s) to a regular user: %s", user, err)
 	}
@ -138,7 +147,12 @@ func (api *Client) SetRegular(teamName string, user string) error {
 }

 // SendSSOBindingEmail sends an SSO binding email to the specified user
-func (api *Client) SendSSOBindingEmail(teamName string, user string) error {
+func (api *Client) SendSSOBindingEmail(teamName, user string) error {
+	return api.SendSSOBindingEmailContext(context.Background(), teamName, user)
+}
+
+// SendSSOBindingEmailContext sends an SSO binding email to the specified user with a custom context
+func (api *Client) SendSSOBindingEmailContext(ctx context.Context, teamName, user string) error {
 	values := url.Values{
 		"user":       {user},
 		"token":      {api.config.token},
@ -146,7 +160,7 @@ func (api *Client) SendSSOBindingEmail(teamName string, user string) error {
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("sendSSOBind", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "sendSSOBind", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to send SSO binding email for user (%s): %s", user, err)
 	}
@ -156,6 +170,11 @@ func (api *Client) SendSSOBindingEmail(teamName string, user string) error {

 // SetUltraRestricted converts a user into a single-channel guest
 func (api *Client) SetUltraRestricted(teamName, uid, channel string) error {
+	return api.SetUltraRestrictedContext(context.Background(), teamName, uid, channel)
+}
+
+// SetUltraRestrictedContext converts a user into a single-channel guest with a custom context
+func (api *Client) SetUltraRestrictedContext(ctx context.Context, teamName, uid, channel string) error {
 	values := url.Values{
 		"user":       {uid},
 		"channel":    {channel},
@ -164,7 +183,7 @@ func (api *Client) SetUltraRestricted(teamName, uid, channel string) error {
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("setUltraRestricted", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "setUltraRestricted", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to ultra-restrict account: %s", err)
 	}
@ -174,6 +193,11 @@ func (api *Client) SetUltraRestricted(teamName, uid, channel string) error {

 // SetRestricted converts a user into a restricted account
 func (api *Client) SetRestricted(teamName, uid string) error {
+	return api.SetRestrictedContext(context.Background(), teamName, uid)
+}
+
+// SetRestrictedContext converts a user into a restricted account with a custom context
+func (api *Client) SetRestrictedContext(ctx context.Context, teamName, uid string) error {
 	values := url.Values{
 		"user":       {uid},
 		"token":      {api.config.token},
@ -181,7 +205,7 @@ func (api *Client) SetRestricted(teamName, uid string) error {
 		"_attempts":  {"1"},
 	}

-	_, err := adminRequest("setRestricted", teamName, values, api.debug)
+	_, err := adminRequest(ctx, "setRestricted", teamName, values, api.debug)
 	if err != nil {
 		return fmt.Errorf("Failed to restrict account: %s", err)
 	}
--- a/vendor/github.com/nlopes/slack/attachments.go
+++ b/vendor/github.com/nlopes/slack/attachments.go
@ -10,16 +10,34 @@ type AttachmentField struct {
 	Short bool   `json:"short"`
 }

-// AttachmentAction is a button to be included in the attachment. Required when
-// using message buttons and otherwise not useful. A maximum of 5 actions may be
+// AttachmentAction is a button or menu to be included in the attachment. Required when
+// using message buttons or menus and otherwise not useful. A maximum of 5 actions may be
 // provided per attachment.
 type AttachmentAction struct {
-	Name    string             `json:"name"`              // Required.
-	Text    string             `json:"text"`              // Required.
-	Style   string             `json:"style,omitempty"`   // Optional. Allowed values: "default", "primary", "danger"
-	Type    string             `json:"type"`              // Required. Must be set to "button"
-	Value   string             `json:"value,omitempty"`   // Optional.
-	Confirm *ConfirmationField `json:"confirm,omitempty"` // Optional.
+	Name            string                        `json:"name"`                       // Required.
+	Text            string                        `json:"text"`                       // Required.
+	Style           string                        `json:"style,omitempty"`            // Optional. Allowed values: "default", "primary", "danger".
+	Type            string                        `json:"type"`                       // Required. Must be set to "button" or "select".
+	Value           string                        `json:"value,omitempty"`            // Optional.
+	DataSource      string                        `json:"data_source,omitempty"`      // Optional.
+	MinQueryLength  int                           `json:"min_query_length,omitempty"` // Optional. Default value is 1.
+	Options         []AttachmentActionOption      `json:"options,omitempty"`          // Optional. Maximum of 100 options can be provided in each menu.
+	SelectedOptions []AttachmentActionOption      `json:"selected_options,omitempty"` // Optional. The first element of this array will be set as the pre-selected option for this menu.
+	OptionGroups    []AttachmentActionOptionGroup `json:"option_groups,omitempty"`    // Optional.
+	Confirm         *ConfirmationField            `json:"confirm,omitempty"`          // Optional.
+}
+
+// AttachmentActionOption the individual option to appear in action menu.
+type AttachmentActionOption struct {
+	Text        string `json:"text"`                  // Required.
+	Value       string `json:"value"`                 // Required.
+	Description string `json:"description,omitempty"` // Optional. Up to 30 characters.
+}
+
+// AttachmentActionOptionGroup is a semi-hierarchal way to list available options to appear in action menu.
+type AttachmentActionOptionGroup struct {
+	Text    string                   `json:"text"`    // Required.
+	Options []AttachmentActionOption `json:"options"` // Required.
 }

 // AttachmentActionCallback is sent from Slack when a user clicks a button in an interactive message (aka AttachmentAction)
--- a/vendor/github.com/nlopes/slack/bots.go
+++ b/vendor/github.com/nlopes/slack/bots.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 )
@ -18,9 +19,9 @@ type botResponseFull struct {
 	SlackResponse
 }

-func botRequest(path string, values url.Values, debug bool) (*botResponseFull, error) {
+func botRequest(ctx context.Context, path string, values url.Values, debug bool) (*botResponseFull, error) {
 	response := &botResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -32,11 +33,16 @@ func botRequest(path string, values url.Values, debug bool) (*botResponseFull, e

 // GetBotInfo will retrieve the complete bot information
 func (api *Client) GetBotInfo(bot string) (*Bot, error) {
+	return api.GetBotInfoContext(context.Background(), bot)
+}
+
+// GetBotInfoContext will retrieve the complete bot information using a custom context
+func (api *Client) GetBotInfoContext(ctx context.Context, bot string) (*Bot, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"bot":   {bot},
 	}
-	response, err := botRequest("bots.info", values, api.debug)
+	response, err := botRequest(ctx, "bots.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/channels.go
+++ b/vendor/github.com/nlopes/slack/channels.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -24,9 +25,9 @@ type Channel struct {
 	IsMember  bool `json:"is_member"`
 }

-func channelRequest(path string, values url.Values, debug bool) (*channelResponseFull, error) {
+func channelRequest(ctx context.Context, path string, values url.Values, debug bool) (*channelResponseFull, error) {
 	response := &channelResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -38,11 +39,16 @@ func channelRequest(path string, values url.Values, debug bool) (*channelRespons

 // ArchiveChannel archives the given channel
 func (api *Client) ArchiveChannel(channel string) error {
+	return api.ArchiveChannelContext(context.Background(), channel)
+}
+
+// ArchiveChannelContext archives the given channel with a custom context
+func (api *Client) ArchiveChannelContext(ctx context.Context, channel string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 	}
-	_, err := channelRequest("channels.archive", values, api.debug)
+	_, err := channelRequest(ctx, "channels.archive", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -51,11 +57,16 @@ func (api *Client) ArchiveChannel(channel string) error {

 // UnarchiveChannel unarchives the given channel
 func (api *Client) UnarchiveChannel(channel string) error {
+	return api.UnarchiveChannelContext(context.Background(), channel)
+}
+
+// UnarchiveChannelContext unarchives the given channel with a custom context
+func (api *Client) UnarchiveChannelContext(ctx context.Context, channel string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 	}
-	_, err := channelRequest("channels.unarchive", values, api.debug)
+	_, err := channelRequest(ctx, "channels.unarchive", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -64,11 +75,16 @@ func (api *Client) UnarchiveChannel(channel string) error {

 // CreateChannel creates a channel with the given name and returns a *Channel
 func (api *Client) CreateChannel(channel string) (*Channel, error) {
+	return api.CreateChannelContext(context.Background(), channel)
+}
+
+// CreateChannelContext creates a channel with the given name and returns a *Channel with a custom context
+func (api *Client) CreateChannelContext(ctx context.Context, channel string) (*Channel, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"name":  {channel},
 	}
-	response, err := channelRequest("channels.create", values, api.debug)
+	response, err := channelRequest(ctx, "channels.create", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -77,6 +93,11 @@ func (api *Client) CreateChannel(channel string) (*Channel, error) {

 // GetChannelHistory retrieves the channel history
 func (api *Client) GetChannelHistory(channel string, params HistoryParameters) (*History, error) {
+	return api.GetChannelHistoryContext(context.Background(), channel, params)
+}
+
+// GetChannelHistoryContext retrieves the channel history with a custom context
+func (api *Client) GetChannelHistoryContext(ctx context.Context, channel string, params HistoryParameters) (*History, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
@ -104,7 +125,7 @@ func (api *Client) GetChannelHistory(channel string, params HistoryParameters) (
 			values.Add("unreads", "0")
 		}
 	}
-	response, err := channelRequest("channels.history", values, api.debug)
+	response, err := channelRequest(ctx, "channels.history", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -113,11 +134,16 @@ func (api *Client) GetChannelHistory(channel string, params HistoryParameters) (

 // GetChannelInfo retrieves the given channel
 func (api *Client) GetChannelInfo(channel string) (*Channel, error) {
+	return api.GetChannelInfoContext(context.Background(), channel)
+}
+
+// GetChannelInfoContext retrieves the given channel with a custom context
+func (api *Client) GetChannelInfoContext(ctx context.Context, channel string) (*Channel, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 	}
-	response, err := channelRequest("channels.info", values, api.debug)
+	response, err := channelRequest(ctx, "channels.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -126,12 +152,17 @@ func (api *Client) GetChannelInfo(channel string) (*Channel, error) {

 // InviteUserToChannel invites a user to a given channel and returns a *Channel
 func (api *Client) InviteUserToChannel(channel, user string) (*Channel, error) {
+	return api.InviteUserToChannelContext(context.Background(), channel, user)
+}
+
+// InviteUserToChannelCustom invites a user to a given channel and returns a *Channel with a custom context
+func (api *Client) InviteUserToChannelContext(ctx context.Context, channel, user string) (*Channel, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"user":    {user},
 	}
-	response, err := channelRequest("channels.invite", values, api.debug)
+	response, err := channelRequest(ctx, "channels.invite", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -140,11 +171,16 @@ func (api *Client) InviteUserToChannel(channel, user string) (*Channel, error) {

 // JoinChannel joins the currently authenticated user to a channel
 func (api *Client) JoinChannel(channel string) (*Channel, error) {
+	return api.JoinChannelContext(context.Background(), channel)
+}
+
+// JoinChannelContext joins the currently authenticated user to a channel with a custom context
+func (api *Client) JoinChannelContext(ctx context.Context, channel string) (*Channel, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"name":  {channel},
 	}
-	response, err := channelRequest("channels.join", values, api.debug)
+	response, err := channelRequest(ctx, "channels.join", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -153,11 +189,16 @@ func (api *Client) JoinChannel(channel string) (*Channel, error) {

 // LeaveChannel makes the authenticated user leave the given channel
 func (api *Client) LeaveChannel(channel string) (bool, error) {
+	return api.LeaveChannelContext(context.Background(), channel)
+}
+
+// LeaveChannelContext makes the authenticated user leave the given channel with a custom context
+func (api *Client) LeaveChannelContext(ctx context.Context, channel string) (bool, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 	}
-	response, err := channelRequest("channels.leave", values, api.debug)
+	response, err := channelRequest(ctx, "channels.leave", values, api.debug)
 	if err != nil {
 		return false, err
 	}
@ -169,12 +210,17 @@ func (api *Client) LeaveChannel(channel string) (bool, error) {

 // KickUserFromChannel kicks a user from a given channel
 func (api *Client) KickUserFromChannel(channel, user string) error {
+	return api.KickUserFromChannelContext(context.Background(), channel, user)
+}
+
+// KickUserFromChannelContext kicks a user from a given channel with a custom context
+func (api *Client) KickUserFromChannelContext(ctx context.Context, channel, user string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"user":    {user},
 	}
-	_, err := channelRequest("channels.kick", values, api.debug)
+	_, err := channelRequest(ctx, "channels.kick", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -183,13 +229,18 @@ func (api *Client) KickUserFromChannel(channel, user string) error {

 // GetChannels retrieves all the channels
 func (api *Client) GetChannels(excludeArchived bool) ([]Channel, error) {
+	return api.GetChannelsContext(context.Background(), excludeArchived)
+}
+
+// GetChannelsContext retrieves all the channels with a custom context
+func (api *Client) GetChannelsContext(ctx context.Context, excludeArchived bool) ([]Channel, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
 	if excludeArchived {
 		values.Add("exclude_archived", "1")
 	}
-	response, err := channelRequest("channels.list", values, api.debug)
+	response, err := channelRequest(ctx, "channels.list", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -202,12 +253,18 @@ func (api *Client) GetChannels(excludeArchived bool) ([]Channel, error) {
 // (just one per channel). This is useful for when reading scroll-back history, or following a busy live channel. A
 // timeout of 5 seconds is a good starting point. Be sure to flush these calls on shutdown/logout.
 func (api *Client) SetChannelReadMark(channel, ts string) error {
+	return api.SetChannelReadMarkContext(context.Background(), channel, ts)
+}
+
+// SetChannelReadMarkContext sets the read mark of a given channel to a specific point with a custom context
+// For more details see SetChannelReadMark documentation
+func (api *Client) SetChannelReadMarkContext(ctx context.Context, channel, ts string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"ts":      {ts},
 	}
-	_, err := channelRequest("channels.mark", values, api.debug)
+	_, err := channelRequest(ctx, "channels.mark", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -216,6 +273,11 @@ func (api *Client) SetChannelReadMark(channel, ts string) error {

 // RenameChannel renames a given channel
 func (api *Client) RenameChannel(channel, name string) (*Channel, error) {
+	return api.RenameChannelContext(context.Background(), channel, name)
+}
+
+// RenameChannelContext renames a given channel with a custom context
+func (api *Client) RenameChannelContext(ctx context.Context, channel, name string) (*Channel, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
@ -223,23 +285,26 @@ func (api *Client) RenameChannel(channel, name string) (*Channel, error) {
 	}
 	// XXX: the created entry in this call returns a string instead of a number
 	// so I may have to do some workaround to solve it.
-	response, err := channelRequest("channels.rename", values, api.debug)
+	response, err := channelRequest(ctx, "channels.rename", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
 	return &response.Channel, nil
-
 }

-// SetChannelPurpose sets the channel purpose and returns the purpose that was
-// successfully set
+// SetChannelPurpose sets the channel purpose and returns the purpose that was successfully set
 func (api *Client) SetChannelPurpose(channel, purpose string) (string, error) {
+	return api.SetChannelPurposeContext(context.Background(), channel, purpose)
+}
+
+// SetChannelPurposeContext sets the channel purpose and returns the purpose that was successfully set with a custom context
+func (api *Client) SetChannelPurposeContext(ctx context.Context, channel, purpose string) (string, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"purpose": {purpose},
 	}
-	response, err := channelRequest("channels.setPurpose", values, api.debug)
+	response, err := channelRequest(ctx, "channels.setPurpose", values, api.debug)
 	if err != nil {
 		return "", err
 	}
@ -248,14 +313,38 @@ func (api *Client) SetChannelPurpose(channel, purpose string) (string, error) {

 // SetChannelTopic sets the channel topic and returns the topic that was successfully set
 func (api *Client) SetChannelTopic(channel, topic string) (string, error) {
+	return api.SetChannelTopicContext(context.Background(), channel, topic)
+}
+
+// SetChannelTopicContext sets the channel topic and returns the topic that was successfully set with a custom context
+func (api *Client) SetChannelTopicContext(ctx context.Context, channel, topic string) (string, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"topic":   {topic},
 	}
-	response, err := channelRequest("channels.setTopic", values, api.debug)
+	response, err := channelRequest(ctx, "channels.setTopic", values, api.debug)
 	if err != nil {
 		return "", err
 	}
 	return response.Topic, nil
 }
+
+// GetChannelReplies gets an entire thread (a message plus all the messages in reply to it).
+func (api *Client) GetChannelReplies(channel, thread_ts string) ([]Message, error) {
+	return api.GetChannelRepliesContext(context.Background(), channel, thread_ts)
+}
+
+// GetChannelRepliesContext gets an entire thread (a message plus all the messages in reply to it) with a custom context
+func (api *Client) GetChannelRepliesContext(ctx context.Context, channel, thread_ts string) ([]Message, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"channel":   {channel},
+		"thread_ts": {thread_ts},
+	}
+	response, err := channelRequest(ctx, "channels.replies", values, api.debug)
+	if err != nil {
+		return nil, err
+	}
+	return response.History.Messages, nil
+}
--- a/vendor/github.com/nlopes/slack/chat.go
+++ b/vendor/github.com/nlopes/slack/chat.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"net/url"
@ -62,9 +63,102 @@ func NewPostMessageParameters() PostMessageParameters {
 	}
 }

-func chatRequest(path string, values url.Values, debug bool) (*chatResponseFull, error) {
+// DeleteMessage deletes a message in a channel
+func (api *Client) DeleteMessage(channel, messageTimestamp string) (string, string, error) {
+	respChannel, respTimestamp, _, err := api.SendMessageContext(context.Background(), channel, MsgOptionDelete(messageTimestamp))
+	return respChannel, respTimestamp, err
+}
+
+// DeleteMessageContext deletes a message in a channel with a custom context
+func (api *Client) DeleteMessageContext(ctx context.Context, channel, messageTimestamp string) (string, string, error) {
+	respChannel, respTimestamp, _, err := api.SendMessageContext(ctx, channel, MsgOptionDelete(messageTimestamp))
+	return respChannel, respTimestamp, err
+}
+
+// PostMessage sends a message to a channel.
+// Message is escaped by default according to https://api.slack.com/docs/formatting
+// Use http://davestevens.github.io/slack-message-builder/ to help crafting your message.
+func (api *Client) PostMessage(channel, text string, params PostMessageParameters) (string, string, error) {
+	respChannel, respTimestamp, _, err := api.SendMessageContext(
+		context.Background(),
+		channel,
+		MsgOptionText(text, params.EscapeText),
+		MsgOptionAttachments(params.Attachments...),
+		MsgOptionPostMessageParameters(params),
+	)
+	return respChannel, respTimestamp, err
+}
+
+// PostMessageContext sends a message to a channel with a custom context
+// For more details, see PostMessage documentation
+func (api *Client) PostMessageContext(ctx context.Context, channel, text string, params PostMessageParameters) (string, string, error) {
+	respChannel, respTimestamp, _, err := api.SendMessageContext(
+		ctx,
+		channel,
+		MsgOptionText(text, params.EscapeText),
+		MsgOptionAttachments(params.Attachments...),
+		MsgOptionPostMessageParameters(params),
+	)
+	return respChannel, respTimestamp, err
+}
+
+// UpdateMessage updates a message in a channel
+func (api *Client) UpdateMessage(channel, timestamp, text string) (string, string, string, error) {
+	return api.UpdateMessageContext(context.Background(), channel, timestamp, text)
+}
+
+// UpdateMessage updates a message in a channel
+func (api *Client) UpdateMessageContext(ctx context.Context, channel, timestamp, text string) (string, string, string, error) {
+	return api.SendMessageContext(ctx, channel, MsgOptionUpdate(timestamp), MsgOptionText(text, true))
+}
+
+// SendMessage more flexible method for configuring messages.
+func (api *Client) SendMessage(channel string, options ...MsgOption) (string, string, string, error) {
+	return api.SendMessageContext(context.Background(), channel, options...)
+}
+
+// SendMessageContext more flexible method for configuring messages with a custom context.
+func (api *Client) SendMessageContext(ctx context.Context, channel string, options ...MsgOption) (string, string, string, error) {
+	channel, values, err := ApplyMsgOptions(api.config.token, channel, options...)
+	if err != nil {
+		return "", "", "", err
+	}
+
+	response, err := chatRequest(ctx, channel, values, api.debug)
+	if err != nil {
+		return "", "", "", err
+	}
+
+	return response.Channel, response.Timestamp, response.Text, nil
+}
+
+// ApplyMsgOptions utility function for debugging/testing chat requests.
+func ApplyMsgOptions(token, channel string, options ...MsgOption) (string, url.Values, error) {
+	config := sendConfig{
+		mode: chatPostMessage,
+		values: url.Values{
+			"token":   {token},
+			"channel": {channel},
+		},
+	}
+
+	for _, opt := range options {
+		if err := opt(&config); err != nil {
+			return string(config.mode), config.values, err
+		}
+	}
+
+	return string(config.mode), config.values, nil
+}
+
+func escapeMessage(message string) string {
+	replacer := strings.NewReplacer("&", "&amp;", "<", "&lt;", ">", "&gt;")
+	return replacer.Replace(message)
+}
+
+func chatRequest(ctx context.Context, path string, values url.Values, debug bool) (*chatResponseFull, error) {
 	response := &chatResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -74,98 +168,153 @@ func chatRequest(path string, values url.Values, debug bool) (*chatResponseFull,
 	return response, nil
 }

-// DeleteMessage deletes a message in a channel
-func (api *Client) DeleteMessage(channel, messageTimestamp string) (string, string, error) {
-	values := url.Values{
-		"token":   {api.config.token},
-		"channel": {channel},
-		"ts":      {messageTimestamp},
-	}
-	response, err := chatRequest("chat.delete", values, api.debug)
-	if err != nil {
-		return "", "", err
-	}
-	return response.Channel, response.Timestamp, nil
+type sendMode string
+
+const (
+	chatUpdate      sendMode = "chat.update"
+	chatPostMessage sendMode = "chat.postMessage"
+	chatDelete      sendMode = "chat.delete"
+)
+
+type sendConfig struct {
+	mode   sendMode
+	values url.Values
 }

-func escapeMessage(message string) string {
-	replacer := strings.NewReplacer("&", "&amp;", "<", "&lt;", ">", "&gt;")
-	return replacer.Replace(message)
+// MsgOption option provided when sending a message.
+type MsgOption func(*sendConfig) error
+
+// MsgOptionPost posts a messages, this is the default.
+func MsgOptionPost() MsgOption {
+	return func(config *sendConfig) error {
+		config.mode = chatPostMessage
+		config.values.Del("ts")
+		return nil
+	}
 }

-// PostMessage sends a message to a channel.
-// Message is escaped by default according to https://api.slack.com/docs/formatting
-// Use http://davestevens.github.io/slack-message-builder/ to help crafting your message.
-func (api *Client) PostMessage(channel, text string, params PostMessageParameters) (string, string, error) {
-	if params.EscapeText {
-		text = escapeMessage(text)
+// MsgOptionUpdate updates a message based on the timestamp.
+func MsgOptionUpdate(timestamp string) MsgOption {
+	return func(config *sendConfig) error {
+		config.mode = chatUpdate
+		config.values.Add("ts", timestamp)
+		return nil
 	}
-	values := url.Values{
-		"token":   {api.config.token},
-		"channel": {channel},
-		"text":    {text},
+}
+
+// MsgOptionDelete deletes a message based on the timestamp.
+func MsgOptionDelete(timestamp string) MsgOption {
+	return func(config *sendConfig) error {
+		config.mode = chatDelete
+		config.values.Add("ts", timestamp)
+		return nil
 	}
-	if params.Username != DEFAULT_MESSAGE_USERNAME {
-		values.Set("username", string(params.Username))
-	}
-	if params.AsUser != DEFAULT_MESSAGE_ASUSER {
-		values.Set("as_user", "true")
-	}
-	if params.Parse != DEFAULT_MESSAGE_PARSE {
-		values.Set("parse", string(params.Parse))
-	}
-	if params.LinkNames != DEFAULT_MESSAGE_LINK_NAMES {
-		values.Set("link_names", "1")
-	}
-	if params.Attachments != nil {
-		attachments, err := json.Marshal(params.Attachments)
-		if err != nil {
-			return "", "", err
+}
+
+// MsgOptionAsUser whether or not to send the message as the user.
+func MsgOptionAsUser(b bool) MsgOption {
+	return func(config *sendConfig) error {
+		if b != DEFAULT_MESSAGE_ASUSER {
+			config.values.Set("as_user", "true")
 		}
-		values.Set("attachments", string(attachments))
+		return nil
 	}
-	if params.UnfurlLinks != DEFAULT_MESSAGE_UNFURL_LINKS {
-		values.Set("unfurl_links", "true")
-	}
-	// I want to send a message with explicit `as_user` `true` and `unfurl_links` `false` in request.
-	// Because setting `as_user` to `true` will change the default value for `unfurl_links` to `true` on Slack API side.
-	if params.AsUser != DEFAULT_MESSAGE_ASUSER && params.UnfurlLinks == DEFAULT_MESSAGE_UNFURL_LINKS {
-		values.Set("unfurl_links", "false")
-	}
-	if params.UnfurlMedia != DEFAULT_MESSAGE_UNFURL_MEDIA {
-		values.Set("unfurl_media", "false")
-	}
-	if params.IconURL != DEFAULT_MESSAGE_ICON_URL {
-		values.Set("icon_url", params.IconURL)
-	}
-	if params.IconEmoji != DEFAULT_MESSAGE_ICON_EMOJI {
-		values.Set("icon_emoji", params.IconEmoji)
-	}
-	if params.Markdown != DEFAULT_MESSAGE_MARKDOWN {
-		values.Set("mrkdwn", "false")
-	}
-	if params.ThreadTimestamp != DEFAULT_MESSAGE_THREAD_TIMESTAMP {
-		values.Set("thread_ts", params.ThreadTimestamp)
-	}
-
-	response, err := chatRequest("chat.postMessage", values, api.debug)
-	if err != nil {
-		return "", "", err
-	}
-	return response.Channel, response.Timestamp, nil
 }

-// UpdateMessage updates a message in a channel
-func (api *Client) UpdateMessage(channel, timestamp, text string) (string, string, string, error) {
-	values := url.Values{
-		"token":   {api.config.token},
-		"channel": {channel},
-		"text":    {escapeMessage(text)},
-		"ts":      {timestamp},
+// MsgOptionText provide the text for the message, optionally escape the provided
+// text.
+func MsgOptionText(text string, escape bool) MsgOption {
+	return func(config *sendConfig) error {
+		if escape {
+			text = escapeMessage(text)
+		}
+		config.values.Add("text", text)
+		return nil
+	}
+}
+
+// MsgOptionAttachments provide attachments for the message.
+func MsgOptionAttachments(attachments ...Attachment) MsgOption {
+	return func(config *sendConfig) error {
+		if attachments == nil {
+			return nil
+		}
+
+		attachments, err := json.Marshal(attachments)
+		if err == nil {
+			config.values.Set("attachments", string(attachments))
+		}
+		return err
+	}
+}
+
+// MsgOptionEnableLinkUnfurl enables link unfurling
+func MsgOptionEnableLinkUnfurl() MsgOption {
+	return func(config *sendConfig) error {
+		config.values.Set("unfurl_links", "true")
+		return nil
+	}
+}
+
+// MsgOptionDisableMediaUnfurl disables media unfurling.
+func MsgOptionDisableMediaUnfurl() MsgOption {
+	return func(config *sendConfig) error {
+		config.values.Set("unfurl_media", "false")
+		return nil
+	}
+}
+
+// MsgOptionDisableMarkdown disables markdown.
+func MsgOptionDisableMarkdown() MsgOption {
+	return func(config *sendConfig) error {
+		config.values.Set("mrkdwn", "false")
+		return nil
+	}
+}
+
+// MsgOptionPostMessageParameters maintain backwards compatibility.
+func MsgOptionPostMessageParameters(params PostMessageParameters) MsgOption {
+	return func(config *sendConfig) error {
+		if params.Username != DEFAULT_MESSAGE_USERNAME {
+			config.values.Set("username", string(params.Username))
+		}
+
+		// never generates an error.
+		MsgOptionAsUser(params.AsUser)(config)
+
+		if params.Parse != DEFAULT_MESSAGE_PARSE {
+			config.values.Set("parse", string(params.Parse))
+		}
+		if params.LinkNames != DEFAULT_MESSAGE_LINK_NAMES {
+			config.values.Set("link_names", "1")
+		}
+
+		if params.UnfurlLinks != DEFAULT_MESSAGE_UNFURL_LINKS {
+			config.values.Set("unfurl_links", "true")
+		}
+
+		// I want to send a message with explicit `as_user` `true` and `unfurl_links` `false` in request.
+		// Because setting `as_user` to `true` will change the default value for `unfurl_links` to `true` on Slack API side.
+		if params.AsUser != DEFAULT_MESSAGE_ASUSER && params.UnfurlLinks == DEFAULT_MESSAGE_UNFURL_LINKS {
+			config.values.Set("unfurl_links", "false")
+		}
+		if params.UnfurlMedia != DEFAULT_MESSAGE_UNFURL_MEDIA {
+			config.values.Set("unfurl_media", "false")
+		}
+		if params.IconURL != DEFAULT_MESSAGE_ICON_URL {
+			config.values.Set("icon_url", params.IconURL)
+		}
+		if params.IconEmoji != DEFAULT_MESSAGE_ICON_EMOJI {
+			config.values.Set("icon_emoji", params.IconEmoji)
+		}
+		if params.Markdown != DEFAULT_MESSAGE_MARKDOWN {
+			config.values.Set("mrkdwn", "false")
+		}
+
+		if params.ThreadTimestamp != DEFAULT_MESSAGE_THREAD_TIMESTAMP {
+			config.values.Set("thread_ts", params.ThreadTimestamp)
+		}
+
+		return nil
 	}
-	response, err := chatRequest("chat.update", values, api.debug)
-	if err != nil {
-		return "", "", "", err
-	}
-	return response.Channel, response.Timestamp, response.Text, nil
 }
--- a/vendor/github.com/nlopes/slack/dnd.go
+++ b/vendor/github.com/nlopes/slack/dnd.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -35,9 +36,9 @@ type dndTeamInfoResponse struct {
 	SlackResponse
 }

-func dndRequest(path string, values url.Values, debug bool) (*dndResponseFull, error) {
+func dndRequest(ctx context.Context, path string, values url.Values, debug bool) (*dndResponseFull, error) {
 	response := &dndResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -49,12 +50,17 @@ func dndRequest(path string, values url.Values, debug bool) (*dndResponseFull, e

 // EndDND ends the user's scheduled Do Not Disturb session
 func (api *Client) EndDND() error {
+	return api.EndDNDContext(context.Background())
+}
+
+// EndDNDContext ends the user's scheduled Do Not Disturb session with a custom context
+func (api *Client) EndDNDContext(ctx context.Context) error {
 	values := url.Values{
 		"token": {api.config.token},
 	}

 	response := &SlackResponse{}
-	if err := post("dnd.endDnd", values, response, api.debug); err != nil {
+	if err := post(ctx, "dnd.endDnd", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -65,11 +71,16 @@ func (api *Client) EndDND() error {

 // EndSnooze ends the current user's snooze mode
 func (api *Client) EndSnooze() (*DNDStatus, error) {
+	return api.EndSnoozeContext(context.Background())
+}
+
+// EndSnoozeContext ends the current user's snooze mode with a custom context
+func (api *Client) EndSnoozeContext(ctx context.Context) (*DNDStatus, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}

-	response, err := dndRequest("dnd.endSnooze", values, api.debug)
+	response, err := dndRequest(ctx, "dnd.endSnooze", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -78,13 +89,18 @@ func (api *Client) EndSnooze() (*DNDStatus, error) {

 // GetDNDInfo provides information about a user's current Do Not Disturb settings.
 func (api *Client) GetDNDInfo(user *string) (*DNDStatus, error) {
+	return api.GetDNDInfoContext(context.Background(), user)
+}
+
+// GetDNDInfoContext provides information about a user's current Do Not Disturb settings with a custom context.
+func (api *Client) GetDNDInfoContext(ctx context.Context, user *string) (*DNDStatus, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
 	if user != nil {
 		values.Set("user", *user)
 	}
-	response, err := dndRequest("dnd.info", values, api.debug)
+	response, err := dndRequest(ctx, "dnd.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -93,12 +109,17 @@ func (api *Client) GetDNDInfo(user *string) (*DNDStatus, error) {

 // GetDNDTeamInfo provides information about a user's current Do Not Disturb settings.
 func (api *Client) GetDNDTeamInfo(users []string) (map[string]DNDStatus, error) {
+	return api.GetDNDTeamInfoContext(context.Background(), users)
+}
+
+// GetDNDTeamInfoContext provides information about a user's current Do Not Disturb settings with a custom context.
+func (api *Client) GetDNDTeamInfoContext(ctx context.Context, users []string) (map[string]DNDStatus, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"users": {strings.Join(users, ",")},
 	}
 	response := &dndTeamInfoResponse{}
-	if err := post("dnd.teamInfo", values, response, api.debug); err != nil {
+	if err := post(ctx, "dnd.teamInfo", values, response, api.debug); err != nil {
 		return nil, err
 	}
 	if !response.Ok {
@ -111,11 +132,17 @@ func (api *Client) GetDNDTeamInfo(users []string) (map[string]DNDStatus, error)
 // settings. If a snooze session is not already active for the user, invoking
 // this method will begin one for the specified duration.
 func (api *Client) SetSnooze(minutes int) (*DNDStatus, error) {
+	return api.SetSnoozeContext(context.Background(), minutes)
+}
+
+// SetSnooze adjusts the snooze duration for a user's Do Not Disturb settings with a custom context.
+// For more information see the SetSnooze docs
+func (api *Client) SetSnoozeContext(ctx context.Context, minutes int) (*DNDStatus, error) {
 	values := url.Values{
 		"token":       {api.config.token},
 		"num_minutes": {strconv.Itoa(minutes)},
 	}
-	response, err := dndRequest("dnd.setSnooze", values, api.debug)
+	response, err := dndRequest(ctx, "dnd.setSnooze", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/emoji.go
+++ b/vendor/github.com/nlopes/slack/emoji.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 )
@ -12,11 +13,16 @@ type emojiResponseFull struct {

 // GetEmoji retrieves all the emojis
 func (api *Client) GetEmoji() (map[string]string, error) {
+	return api.GetEmojiContext(context.Background())
+}
+
+// GetEmojiContext retrieves all the emojis with a custom context
+func (api *Client) GetEmojiContext(ctx context.Context) (map[string]string, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
 	response := &emojiResponseFull{}
-	err := post("emoji.list", values, response, api.debug)
+	err := post(ctx, "emoji.list", values, response, api.debug)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/examples/channels/channels.go
+++ b/vendor/github.com/nlopes/slack/examples/channels/channels.go
@ -14,6 +14,8 @@ func main() {
 		return
 	}
 	for _, channel := range channels {
-		fmt.Println(channel.ID)
+		fmt.Println(channel.Name)
+		// channel is of type conversation & groupConversation
+		// see all available methods in `conversation.go`
 	}
 }
--- a/vendor/github.com/nlopes/slack/files.go
+++ b/vendor/github.com/nlopes/slack/files.go
@ -1,7 +1,9 @@
 package slack

 import (
+	"context"
 	"errors"
+	"io"
 	"net/url"
 	"strconv"
 	"strings"
@ -86,10 +88,14 @@ type File struct {
 	IsStarred       bool     `json:"is_starred"`
 }

-// FileUploadParameters contains all the parameters necessary (including the optional ones) for an UploadFile() request
+// FileUploadParameters contains all the parameters necessary (including the optional ones) for an UploadFile() request.
+//
+// There are three ways to upload a file. You can either set Content if file is small, set Reader if file is large,
+// or provide a local file path in File to upload it from your filesystem.
 type FileUploadParameters struct {
 	File           string
 	Content        string
+	Reader         io.Reader
 	Filetype       string
 	Filename       string
 	Title          string
@ -130,9 +136,9 @@ func NewGetFilesParameters() GetFilesParameters {
 	}
 }

-func fileRequest(path string, values url.Values, debug bool) (*fileResponseFull, error) {
+func fileRequest(ctx context.Context, path string, values url.Values, debug bool) (*fileResponseFull, error) {
 	response := &fileResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -144,13 +150,18 @@ func fileRequest(path string, values url.Values, debug bool) (*fileResponseFull,

 // GetFileInfo retrieves a file and related comments
 func (api *Client) GetFileInfo(fileID string, count, page int) (*File, []Comment, *Paging, error) {
+	return api.GetFileInfoContext(context.Background(), fileID, count, page)
+}
+
+// GetFileInfoContext retrieves a file and related comments with a custom context
+func (api *Client) GetFileInfoContext(ctx context.Context, fileID string, count, page int) (*File, []Comment, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"file":  {fileID},
 		"count": {strconv.Itoa(count)},
 		"page":  {strconv.Itoa(page)},
 	}
-	response, err := fileRequest("files.info", values, api.debug)
+	response, err := fileRequest(ctx, "files.info", values, api.debug)
 	if err != nil {
 		return nil, nil, nil, err
 	}
@ -159,6 +170,11 @@ func (api *Client) GetFileInfo(fileID string, count, page int) (*File, []Comment

 // GetFiles retrieves all files according to the parameters given
 func (api *Client) GetFiles(params GetFilesParameters) ([]File, *Paging, error) {
+	return api.GetFilesContext(context.Background(), params)
+}
+
+// GetFilesContext retrieves all files according to the parameters given with a custom context
+func (api *Client) GetFilesContext(ctx context.Context, params GetFilesParameters) ([]File, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -168,12 +184,11 @@ func (api *Client) GetFiles(params GetFilesParameters) ([]File, *Paging, error)
 	if params.Channel != DEFAULT_FILES_CHANNEL {
 		values.Add("channel", params.Channel)
 	}
-	// XXX: this is broken. fix it with a proper unix timestamp
 	if params.TimestampFrom != DEFAULT_FILES_TS_FROM {
-		values.Add("ts_from", params.TimestampFrom.String())
+		values.Add("ts_from", strconv.FormatInt(int64(params.TimestampFrom), 10))
 	}
 	if params.TimestampTo != DEFAULT_FILES_TS_TO {
-		values.Add("ts_to", params.TimestampTo.String())
+		values.Add("ts_to", strconv.FormatInt(int64(params.TimestampTo), 10))
 	}
 	if params.Types != DEFAULT_FILES_TYPES {
 		values.Add("types", params.Types)
@ -184,7 +199,7 @@ func (api *Client) GetFiles(params GetFilesParameters) ([]File, *Paging, error)
 	if params.Page != DEFAULT_FILES_PAGE {
 		values.Add("page", strconv.Itoa(params.Page))
 	}
-	response, err := fileRequest("files.list", values, api.debug)
+	response, err := fileRequest(ctx, "files.list", values, api.debug)
 	if err != nil {
 		return nil, nil, err
 	}
@ -193,6 +208,11 @@ func (api *Client) GetFiles(params GetFilesParameters) ([]File, *Paging, error)

 // UploadFile uploads a file
 func (api *Client) UploadFile(params FileUploadParameters) (file *File, err error) {
+	return api.UploadFileContext(context.Background(), params)
+}
+
+// UploadFileContext uploads a file and setting a custom context
+func (api *Client) UploadFileContext(ctx context.Context, params FileUploadParameters) (file *File, err error) {
 	// Test if user token is valid. This helps because client.Do doesn't like this for some reason. XXX: More
 	// investigation needed, but for now this will do.
 	_, err = api.AuthTest()
@ -220,9 +240,11 @@ func (api *Client) UploadFile(params FileUploadParameters) (file *File, err erro
 	}
 	if params.Content != "" {
 		values.Add("content", params.Content)
-		err = post("files.upload", values, response, api.debug)
+		err = post(ctx, "files.upload", values, response, api.debug)
 	} else if params.File != "" {
-		err = postWithMultipartResponse("files.upload", params.File, values, response, api.debug)
+		err = postLocalWithMultipartResponse(ctx, "files.upload", params.File, "file", values, response, api.debug)
+	} else if params.Reader != nil {
+		err = postWithMultipartResponse(ctx, "files.upload", params.Filename, "file", values, params.Reader, response, api.debug)
 	}
 	if err != nil {
 		return nil, err
@ -235,11 +257,16 @@ func (api *Client) UploadFile(params FileUploadParameters) (file *File, err erro

 // DeleteFile deletes a file
 func (api *Client) DeleteFile(fileID string) error {
+	return api.DeleteFileContext(context.Background(), fileID)
+}
+
+// DeleteFileContext deletes a file with a custom context
+func (api *Client) DeleteFileContext(ctx context.Context, fileID string) error {
 	values := url.Values{
 		"token": {api.config.token},
 		"file":  {fileID},
 	}
-	_, err := fileRequest("files.delete", values, api.debug)
+	_, err := fileRequest(ctx, "files.delete", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -249,11 +276,16 @@ func (api *Client) DeleteFile(fileID string) error {

 // RevokeFilePublicURL disables public/external sharing for a file
 func (api *Client) RevokeFilePublicURL(fileID string) (*File, error) {
+	return api.RevokeFilePublicURLContext(context.Background(), fileID)
+}
+
+// RevokeFilePublicURLContext disables public/external sharing for a file with a custom context
+func (api *Client) RevokeFilePublicURLContext(ctx context.Context, fileID string) (*File, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"file":  {fileID},
 	}
-	response, err := fileRequest("files.revokePublicURL", values, api.debug)
+	response, err := fileRequest(ctx, "files.revokePublicURL", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -262,11 +294,16 @@ func (api *Client) RevokeFilePublicURL(fileID string) (*File, error) {

 // ShareFilePublicURL enabled public/external sharing for a file
 func (api *Client) ShareFilePublicURL(fileID string) (*File, []Comment, *Paging, error) {
+	return api.ShareFilePublicURLContext(context.Background(), fileID)
+}
+
+// ShareFilePublicURLContext enabled public/external sharing for a file with a custom context
+func (api *Client) ShareFilePublicURLContext(ctx context.Context, fileID string) (*File, []Comment, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"file":  {fileID},
 	}
-	response, err := fileRequest("files.sharedPublicURL", values, api.debug)
+	response, err := fileRequest(ctx, "files.sharedPublicURL", values, api.debug)
 	if err != nil {
 		return nil, nil, nil, err
 	}
--- a/vendor/github.com/nlopes/slack/groups.go
+++ b/vendor/github.com/nlopes/slack/groups.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -27,9 +28,9 @@ type groupResponseFull struct {
 	SlackResponse
 }

-func groupRequest(path string, values url.Values, debug bool) (*groupResponseFull, error) {
+func groupRequest(ctx context.Context, path string, values url.Values, debug bool) (*groupResponseFull, error) {
 	response := &groupResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -41,11 +42,16 @@ func groupRequest(path string, values url.Values, debug bool) (*groupResponseFul

 // ArchiveGroup archives a private group
 func (api *Client) ArchiveGroup(group string) error {
+	return api.ArchiveGroupContext(context.Background(), group)
+}
+
+// ArchiveGroup archives a private group
+func (api *Client) ArchiveGroupContext(ctx context.Context, group string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	_, err := groupRequest("groups.archive", values, api.debug)
+	_, err := groupRequest(ctx, "groups.archive", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -54,11 +60,16 @@ func (api *Client) ArchiveGroup(group string) error {

 // UnarchiveGroup unarchives a private group
 func (api *Client) UnarchiveGroup(group string) error {
+	return api.UnarchiveGroupContext(context.Background(), group)
+}
+
+// UnarchiveGroup unarchives a private group
+func (api *Client) UnarchiveGroupContext(ctx context.Context, group string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	_, err := groupRequest("groups.unarchive", values, api.debug)
+	_, err := groupRequest(ctx, "groups.unarchive", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -67,11 +78,16 @@ func (api *Client) UnarchiveGroup(group string) error {

 // CreateGroup creates a private group
 func (api *Client) CreateGroup(group string) (*Group, error) {
+	return api.CreateGroupContext(context.Background(), group)
+}
+
+// CreateGroup creates a private group
+func (api *Client) CreateGroupContext(ctx context.Context, group string) (*Group, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"name":  {group},
 	}
-	response, err := groupRequest("groups.create", values, api.debug)
+	response, err := groupRequest(ctx, "groups.create", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -85,11 +101,17 @@ func (api *Client) CreateGroup(group string) (*Group, error) {
 //   3. Creates a new group with the name of the existing group.
 //   4. Adds all members of the existing group to the new group.
 func (api *Client) CreateChildGroup(group string) (*Group, error) {
+	return api.CreateChildGroupContext(context.Background(), group)
+}
+
+// CreateChildGroup creates a new private group archiving the old one with a custom context
+// For more information see CreateChildGroup
+func (api *Client) CreateChildGroupContext(ctx context.Context, group string) (*Group, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	response, err := groupRequest("groups.createChild", values, api.debug)
+	response, err := groupRequest(ctx, "groups.createChild", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -98,11 +120,16 @@ func (api *Client) CreateChildGroup(group string) (*Group, error) {

 // CloseGroup closes a private group
 func (api *Client) CloseGroup(group string) (bool, bool, error) {
+	return api.CloseGroupContext(context.Background(), group)
+}
+
+// CloseGroupContext closes a private group with a custom context
+func (api *Client) CloseGroupContext(ctx context.Context, group string) (bool, bool, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	response, err := imRequest("groups.close", values, api.debug)
+	response, err := imRequest(ctx, "groups.close", values, api.debug)
 	if err != nil {
 		return false, false, err
 	}
@ -111,6 +138,11 @@ func (api *Client) CloseGroup(group string) (bool, bool, error) {

 // GetGroupHistory fetches all the history for a private group
 func (api *Client) GetGroupHistory(group string, params HistoryParameters) (*History, error) {
+	return api.GetGroupHistoryContext(context.Background(), group, params)
+}
+
+// GetGroupHistoryContext fetches all the history for a private group with a custom context
+func (api *Client) GetGroupHistoryContext(ctx context.Context, group string, params HistoryParameters) (*History, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
@ -138,7 +170,7 @@ func (api *Client) GetGroupHistory(group string, params HistoryParameters) (*His
 			values.Add("unreads", "0")
 		}
 	}
-	response, err := groupRequest("groups.history", values, api.debug)
+	response, err := groupRequest(ctx, "groups.history", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -147,12 +179,17 @@ func (api *Client) GetGroupHistory(group string, params HistoryParameters) (*His

 // InviteUserToGroup invites a specific user to a private group
 func (api *Client) InviteUserToGroup(group, user string) (*Group, bool, error) {
+	return api.InviteUserToGroupContext(context.Background(), group, user)
+}
+
+// InviteUserToGroupContext invites a specific user to a private group with a custom context
+func (api *Client) InviteUserToGroupContext(ctx context.Context, group, user string) (*Group, bool, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 		"user":    {user},
 	}
-	response, err := groupRequest("groups.invite", values, api.debug)
+	response, err := groupRequest(ctx, "groups.invite", values, api.debug)
 	if err != nil {
 		return nil, false, err
 	}
@ -161,11 +198,16 @@ func (api *Client) InviteUserToGroup(group, user string) (*Group, bool, error) {

 // LeaveGroup makes authenticated user leave the group
 func (api *Client) LeaveGroup(group string) error {
+	return api.LeaveGroupContext(context.Background(), group)
+}
+
+// LeaveGroupContext makes authenticated user leave the group with a custom context
+func (api *Client) LeaveGroupContext(ctx context.Context, group string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	_, err := groupRequest("groups.leave", values, api.debug)
+	_, err := groupRequest(ctx, "groups.leave", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -174,12 +216,17 @@ func (api *Client) LeaveGroup(group string) error {

 // KickUserFromGroup kicks a user from a group
 func (api *Client) KickUserFromGroup(group, user string) error {
+	return api.KickUserFromGroupContext(context.Background(), group, user)
+}
+
+// KickUserFromGroupContext kicks a user from a group with a custom context
+func (api *Client) KickUserFromGroupContext(ctx context.Context, group, user string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 		"user":    {user},
 	}
-	_, err := groupRequest("groups.kick", values, api.debug)
+	_, err := groupRequest(ctx, "groups.kick", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -188,13 +235,18 @@ func (api *Client) KickUserFromGroup(group, user string) error {

 // GetGroups retrieves all groups
 func (api *Client) GetGroups(excludeArchived bool) ([]Group, error) {
+	return api.GetGroupsContext(context.Background(), excludeArchived)
+}
+
+// GetGroupsContext retrieves all groups with a custom context
+func (api *Client) GetGroupsContext(ctx context.Context, excludeArchived bool) ([]Group, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
 	if excludeArchived {
 		values.Add("exclude_archived", "1")
 	}
-	response, err := groupRequest("groups.list", values, api.debug)
+	response, err := groupRequest(ctx, "groups.list", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -203,11 +255,16 @@ func (api *Client) GetGroups(excludeArchived bool) ([]Group, error) {

 // GetGroupInfo retrieves the given group
 func (api *Client) GetGroupInfo(group string) (*Group, error) {
+	return api.GetGroupInfoContext(context.Background(), group)
+}
+
+// GetGroupInfoContext retrieves the given group with a custom context
+func (api *Client) GetGroupInfoContext(ctx context.Context, group string) (*Group, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	response, err := groupRequest("groups.info", values, api.debug)
+	response, err := groupRequest(ctx, "groups.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -220,12 +277,18 @@ func (api *Client) GetGroupInfo(group string) (*Group, error) {
 // calls (just one per channel). This is useful for when reading scroll-back history, or following a busy live
 // channel. A timeout of 5 seconds is a good starting point. Be sure to flush these calls on shutdown/logout.
 func (api *Client) SetGroupReadMark(group, ts string) error {
+	return api.SetGroupReadMarkContext(context.Background(), group, ts)
+}
+
+// SetGroupReadMarkContext sets the read mark on a private group with a custom context
+// For more details see SetGroupReadMark
+func (api *Client) SetGroupReadMarkContext(ctx context.Context, group, ts string) error {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 		"ts":      {ts},
 	}
-	_, err := groupRequest("groups.mark", values, api.debug)
+	_, err := groupRequest(ctx, "groups.mark", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -234,11 +297,16 @@ func (api *Client) SetGroupReadMark(group, ts string) error {

 // OpenGroup opens a private group
 func (api *Client) OpenGroup(group string) (bool, bool, error) {
+	return api.OpenGroupContext(context.Background(), group)
+}
+
+// OpenGroupContext opens a private group with a custom context
+func (api *Client) OpenGroupContext(ctx context.Context, group string) (bool, bool, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 	}
-	response, err := groupRequest("groups.open", values, api.debug)
+	response, err := groupRequest(ctx, "groups.open", values, api.debug)
 	if err != nil {
 		return false, false, err
 	}
@ -249,6 +317,11 @@ func (api *Client) OpenGroup(group string) (bool, bool, error) {
 // XXX: They return a channel, not a group. What is this crap? :(
 // Inconsistent api it seems.
 func (api *Client) RenameGroup(group, name string) (*Channel, error) {
+	return api.RenameGroupContext(context.Background(), group, name)
+}
+
+// RenameGroupContext renames a group with a custom context
+func (api *Client) RenameGroupContext(ctx context.Context, group, name string) (*Channel, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
@ -256,22 +329,26 @@ func (api *Client) RenameGroup(group, name string) (*Channel, error) {
 	}
 	// XXX: the created entry in this call returns a string instead of a number
 	// so I may have to do some workaround to solve it.
-	response, err := groupRequest("groups.rename", values, api.debug)
+	response, err := groupRequest(ctx, "groups.rename", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
 	return &response.Channel, nil
-
 }

 // SetGroupPurpose sets the group purpose
 func (api *Client) SetGroupPurpose(group, purpose string) (string, error) {
+	return api.SetGroupPurposeContext(context.Background(), group, purpose)
+}
+
+// SetGroupPurposeContext sets the group purpose with a custom context
+func (api *Client) SetGroupPurposeContext(ctx context.Context, group, purpose string) (string, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 		"purpose": {purpose},
 	}
-	response, err := groupRequest("groups.setPurpose", values, api.debug)
+	response, err := groupRequest(ctx, "groups.setPurpose", values, api.debug)
 	if err != nil {
 		return "", err
 	}
@ -280,12 +357,17 @@ func (api *Client) SetGroupPurpose(group, purpose string) (string, error) {

 // SetGroupTopic sets the group topic
 func (api *Client) SetGroupTopic(group, topic string) (string, error) {
+	return api.SetGroupTopicContext(context.Background(), group, topic)
+}
+
+// SetGroupTopicContext sets the group topic with a custom context
+func (api *Client) SetGroupTopicContext(ctx context.Context, group, topic string) (string, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {group},
 		"topic":   {topic},
 	}
-	response, err := groupRequest("groups.setTopic", values, api.debug)
+	response, err := groupRequest(ctx, "groups.setTopic", values, api.debug)
 	if err != nil {
 		return "", err
 	}
--- a/vendor/github.com/nlopes/slack/im.go
+++ b/vendor/github.com/nlopes/slack/im.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -28,9 +29,9 @@ type IM struct {
 	IsUserDeleted bool   `json:"is_user_deleted"`
 }

-func imRequest(path string, values url.Values, debug bool) (*imResponseFull, error) {
+func imRequest(ctx context.Context, path string, values url.Values, debug bool) (*imResponseFull, error) {
 	response := &imResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -42,11 +43,16 @@ func imRequest(path string, values url.Values, debug bool) (*imResponseFull, err

 // CloseIMChannel closes the direct message channel
 func (api *Client) CloseIMChannel(channel string) (bool, bool, error) {
+	return api.CloseIMChannelContext(context.Background(), channel)
+}
+
+// CloseIMChannelContext closes the direct message channel with a custom context
+func (api *Client) CloseIMChannelContext(ctx context.Context, channel string) (bool, bool, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 	}
-	response, err := imRequest("im.close", values, api.debug)
+	response, err := imRequest(ctx, "im.close", values, api.debug)
 	if err != nil {
 		return false, false, err
 	}
@ -56,11 +62,17 @@ func (api *Client) CloseIMChannel(channel string) (bool, bool, error) {
 // OpenIMChannel opens a direct message channel to the user provided as argument
 // Returns some status and the channel ID
 func (api *Client) OpenIMChannel(user string) (bool, bool, string, error) {
+	return api.OpenIMChannelContext(context.Background(), user)
+}
+
+// OpenIMChannelContext opens a direct message channel to the user provided as argument with a custom context
+// Returns some status and the channel ID
+func (api *Client) OpenIMChannelContext(ctx context.Context, user string) (bool, bool, string, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"user":  {user},
 	}
-	response, err := imRequest("im.open", values, api.debug)
+	response, err := imRequest(ctx, "im.open", values, api.debug)
 	if err != nil {
 		return false, false, "", err
 	}
@ -69,12 +81,17 @@ func (api *Client) OpenIMChannel(user string) (bool, bool, string, error) {

 // MarkIMChannel sets the read mark of a direct message channel to a specific point
 func (api *Client) MarkIMChannel(channel, ts string) (err error) {
+	return api.MarkIMChannelContext(context.Background(), channel, ts)
+}
+
+// MarkIMChannelContext sets the read mark of a direct message channel to a specific point with a custom context
+func (api *Client) MarkIMChannelContext(ctx context.Context, channel, ts string) (err error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
 		"ts":      {ts},
 	}
-	_, err = imRequest("im.mark", values, api.debug)
+	_, err = imRequest(ctx, "im.mark", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -83,6 +100,11 @@ func (api *Client) MarkIMChannel(channel, ts string) (err error) {

 // GetIMHistory retrieves the direct message channel history
 func (api *Client) GetIMHistory(channel string, params HistoryParameters) (*History, error) {
+	return api.GetIMHistoryContext(context.Background(), channel, params)
+}
+
+// GetIMHistoryContext retrieves the direct message channel history with a custom context
+func (api *Client) GetIMHistoryContext(ctx context.Context, channel string, params HistoryParameters) (*History, error) {
 	values := url.Values{
 		"token":   {api.config.token},
 		"channel": {channel},
@ -110,7 +132,7 @@ func (api *Client) GetIMHistory(channel string, params HistoryParameters) (*Hist
 			values.Add("unreads", "0")
 		}
 	}
-	response, err := imRequest("im.history", values, api.debug)
+	response, err := imRequest(ctx, "im.history", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -119,10 +141,15 @@ func (api *Client) GetIMHistory(channel string, params HistoryParameters) (*Hist

 // GetIMChannels returns the list of direct message channels
 func (api *Client) GetIMChannels() ([]IM, error) {
+	return api.GetIMChannelsContext(context.Background())
+}
+
+// GetIMChannelsContext returns the list of direct message channels with a custom context
+func (api *Client) GetIMChannelsContext(ctx context.Context) ([]IM, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
-	response, err := imRequest("im.list", values, api.debug)
+	response, err := imRequest(ctx, "im.list", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/messages.go
+++ b/vendor/github.com/nlopes/slack/messages.go
@ -2,10 +2,11 @@ package slack

 // OutgoingMessage is used for the realtime API, and seems incomplete.
 type OutgoingMessage struct {
-	ID      int    `json:"id"`
-	Channel string `json:"channel,omitempty"`
-	Text    string `json:"text,omitempty"`
-	Type    string `json:"type,omitempty"`
+	ID              int    `json:"id"`
+	Channel         string `json:"channel,omitempty"`
+	Text            string `json:"text,omitempty"`
+	Type            string `json:"type,omitempty"`
+	ThreadTimestamp string `json:"thread_ts,omitempty"`
 }

 // Message is an auxiliary type to allow us to have a message containing sub messages
@ -17,15 +18,16 @@ type Message struct {
 // Msg contains information about a slack message
 type Msg struct {
 	// Basic Message
-	Type        string       `json:"type,omitempty"`
-	Channel     string       `json:"channel,omitempty"`
-	User        string       `json:"user,omitempty"`
-	Text        string       `json:"text,omitempty"`
-	Timestamp   string       `json:"ts,omitempty"`
-	IsStarred   bool         `json:"is_starred,omitempty"`
-	PinnedTo    []string     `json:"pinned_to, omitempty"`
-	Attachments []Attachment `json:"attachments,omitempty"`
-	Edited      *Edited      `json:"edited,omitempty"`
+	Type            string       `json:"type,omitempty"`
+	Channel         string       `json:"channel,omitempty"`
+	User            string       `json:"user,omitempty"`
+	Text            string       `json:"text,omitempty"`
+	Timestamp       string       `json:"ts,omitempty"`
+	ThreadTimestamp string       `json:"thread_ts,omitempty"`
+	IsStarred       bool         `json:"is_starred,omitempty"`
+	PinnedTo        []string     `json:"pinned_to, omitempty"`
+	Attachments     []Attachment `json:"attachments,omitempty"`
+	Edited          *Edited      `json:"edited,omitempty"`

 	// Message Subtypes
 	SubType string `json:"subtype,omitempty"`
@ -56,6 +58,11 @@ type Msg struct {
 	// channel_archive, group_archive
 	Members []string `json:"members,omitempty"`

+	// channels.replies, groups.replies, im.replies, mpim.replies
+	ReplyCount   int     `json:"reply_count,omitempty"`
+	Replies      []Reply `json:"replies,omitempty"`
+	ParentUserId string  `json:"parent_user_id,omitempty"`
+
 	// file_share, file_comment, file_mention
 	File *File `json:"file,omitempty"`

@ -88,6 +95,12 @@ type Edited struct {
 	Timestamp string `json:"ts,omitempty"`
 }

+// Reply contains information about a reply for a thread
+type Reply struct {
+	User      string `json:"user,omitempty"`
+	Timestamp string `json:"ts,omitempty"`
+}
+
 // Event contains the event type
 type Event struct {
 	Type string `json:"type,omitempty"`
--- a/vendor/github.com/nlopes/slack/misc.go
+++ b/vendor/github.com/nlopes/slack/misc.go
@ -2,8 +2,8 @@ package slack

 import (
 	"bytes"
+	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
@ -13,9 +13,22 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 )

+// HTTPRequester defines the minimal interface needed for an http.Client to be implemented.
+//
+// Use it in conjunction with the SetHTTPClient function to allow for other capabilities
+// like a tracing http.Client
+type HTTPRequester interface {
+	Do(*http.Request) (*http.Response, error)
+}
+
+var customHTTPClient HTTPRequester
+
+// HTTPClient sets a custom http.Client
+// deprecated: in favor of SetHTTPClient()
 var HTTPClient = &http.Client{}

 type WebResponse struct {
@ -29,40 +42,24 @@ func (s WebError) Error() string {
 	return string(s)
 }

-func fileUploadReq(path, fpath string, values url.Values) (*http.Request, error) {
-	fullpath, err := filepath.Abs(fpath)
-	if err != nil {
-		return nil, err
-	}
-	file, err := os.Open(fullpath)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
+func fileUploadReq(ctx context.Context, path, fieldname, filename string, values url.Values, r io.Reader) (*http.Request, error) {
 	body := &bytes.Buffer{}
 	wr := multipart.NewWriter(body)

-	ioWriter, err := wr.CreateFormFile("file", filepath.Base(fullpath))
+	ioWriter, err := wr.CreateFormFile(fieldname, filename)
 	if err != nil {
 		wr.Close()
 		return nil, err
 	}
-	bytes, err := io.Copy(ioWriter, file)
+	_, err = io.Copy(ioWriter, r)
 	if err != nil {
 		wr.Close()
 		return nil, err
 	}
 	// Close the multipart writer or the footer won't be written
 	wr.Close()
-	stat, err := file.Stat()
-	if err != nil {
-		return nil, err
-	}
-	if bytes != stat.Size() {
-		return nil, errors.New("could not read the whole file")
-	}
 	req, err := http.NewRequest("POST", path, body)
+	req = req.WithContext(ctx)
 	if err != nil {
 		return nil, err
 	}
@ -90,9 +87,26 @@ func parseResponseBody(body io.ReadCloser, intf *interface{}, debug bool) error
 	return nil
 }

-func postWithMultipartResponse(path string, filepath string, values url.Values, intf interface{}, debug bool) error {
-	req, err := fileUploadReq(SLACK_API+path, filepath, values)
-	resp, err := HTTPClient.Do(req)
+func postLocalWithMultipartResponse(ctx context.Context, path, fpath, fieldname string, values url.Values, intf interface{}, debug bool) error {
+	fullpath, err := filepath.Abs(fpath)
+	if err != nil {
+		return err
+	}
+	file, err := os.Open(fullpath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	return postWithMultipartResponse(ctx, path, filepath.Base(fpath), fieldname, values, file, intf, debug)
+}
+
+func postWithMultipartResponse(ctx context.Context, path, name, fieldname string, values url.Values, r io.Reader, intf interface{}, debug bool) error {
+	req, err := fileUploadReq(ctx, SLACK_API+path, fieldname, name, values, r)
+	if err != nil {
+		return err
+	}
+	req = req.WithContext(ctx)
+	resp, err := getHTTPClient().Do(req)
 	if err != nil {
 		return err
 	}
@ -107,23 +121,37 @@ func postWithMultipartResponse(path string, filepath string, values url.Values,
 	return parseResponseBody(resp.Body, &intf, debug)
 }

-func postForm(endpoint string, values url.Values, intf interface{}, debug bool) error {
-	resp, err := HTTPClient.PostForm(endpoint, values)
+func postForm(ctx context.Context, endpoint string, values url.Values, intf interface{}, debug bool) error {
+	reqBody := strings.NewReader(values.Encode())
+	req, err := http.NewRequest("POST", endpoint, reqBody)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	req = req.WithContext(ctx)
+	resp, err := getHTTPClient().Do(req)
 	if err != nil {
 		return err
 	}
 	defer resp.Body.Close()

+	// Slack seems to send an HTML body along with 5xx error codes. Don't parse it.
+	if resp.StatusCode != 200 {
+		logResponse(resp, debug)
+		return fmt.Errorf("Slack server error: %s.", resp.Status)
+	}
+
 	return parseResponseBody(resp.Body, &intf, debug)
 }

-func post(path string, values url.Values, intf interface{}, debug bool) error {
-	return postForm(SLACK_API+path, values, intf, debug)
+func post(ctx context.Context, path string, values url.Values, intf interface{}, debug bool) error {
+	return postForm(ctx, SLACK_API+path, values, intf, debug)
 }

-func parseAdminResponse(method string, teamName string, values url.Values, intf interface{}, debug bool) error {
+func parseAdminResponse(ctx context.Context, method string, teamName string, values url.Values, intf interface{}, debug bool) error {
 	endpoint := fmt.Sprintf(SLACK_WEB_API_FORMAT, teamName, method, time.Now().Unix())
-	return postForm(endpoint, values, intf, debug)
+	return postForm(ctx, endpoint, values, intf, debug)
 }

 func logResponse(resp *http.Response, debug bool) error {
@ -133,8 +161,23 @@ func logResponse(resp *http.Response, debug bool) error {
 			return err
 		}

-		logger.Print(text)
+		logger.Print(string(text))
 	}

 	return nil
 }
+
+func getHTTPClient() HTTPRequester {
+	if customHTTPClient != nil {
+		return customHTTPClient
+	}
+
+	return HTTPClient
+}
+
+// SetHTTPClient allows you to specify a custom http.Client
+// Use this instead of the package level HTTPClient variable if you want to use a custom client like the
+// Stackdriver Trace HTTPClient https://godoc.org/cloud.google.com/go/trace#HTTPClient
+func SetHTTPClient(client HTTPRequester) {
+	customHTTPClient = client
+}
--- a/vendor/github.com/nlopes/slack/oauth.go
+++ b/vendor/github.com/nlopes/slack/oauth.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 )
@ -30,7 +31,12 @@ type OAuthResponse struct {

 // GetOAuthToken retrieves an AccessToken
 func GetOAuthToken(clientID, clientSecret, code, redirectURI string, debug bool) (accessToken string, scope string, err error) {
-	response, err := GetOAuthResponse(clientID, clientSecret, code, redirectURI, debug)
+	return GetOAuthTokenContext(context.Background(), clientID, clientSecret, code, redirectURI, debug)
+}
+
+// GetOAuthTokenContext retrieves an AccessToken with a custom context
+func GetOAuthTokenContext(ctx context.Context, clientID, clientSecret, code, redirectURI string, debug bool) (accessToken string, scope string, err error) {
+	response, err := GetOAuthResponseContext(ctx, clientID, clientSecret, code, redirectURI, debug)
 	if err != nil {
 		return "", "", err
 	}
@ -38,6 +44,10 @@ func GetOAuthToken(clientID, clientSecret, code, redirectURI string, debug bool)
 }

 func GetOAuthResponse(clientID, clientSecret, code, redirectURI string, debug bool) (resp *OAuthResponse, err error) {
+	return GetOAuthResponseContext(context.Background(), clientID, clientSecret, code, redirectURI, debug)
+}
+
+func GetOAuthResponseContext(ctx context.Context, clientID, clientSecret, code, redirectURI string, debug bool) (resp *OAuthResponse, err error) {
 	values := url.Values{
 		"client_id":     {clientID},
 		"client_secret": {clientSecret},
@ -45,7 +55,7 @@ func GetOAuthResponse(clientID, clientSecret, code, redirectURI string, debug bo
 		"redirect_uri":  {redirectURI},
 	}
 	response := &OAuthResponse{}
-	err = post("oauth.access", values, response, debug)
+	err = post(ctx, "oauth.access", values, response, debug)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/pins.go
+++ b/vendor/github.com/nlopes/slack/pins.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 )
@ -13,6 +14,11 @@ type listPinsResponseFull struct {

 // AddPin pins an item in a channel
 func (api *Client) AddPin(channel string, item ItemRef) error {
+	return api.AddPinContext(context.Background(), channel, item)
+}
+
+// AddPinContext pins an item in a channel with a custom context
+func (api *Client) AddPinContext(ctx context.Context, channel string, item ItemRef) error {
 	values := url.Values{
 		"channel": {channel},
 		"token":   {api.config.token},
@ -27,7 +33,7 @@ func (api *Client) AddPin(channel string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("pins.add", values, response, api.debug); err != nil {
+	if err := post(ctx, "pins.add", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -38,6 +44,11 @@ func (api *Client) AddPin(channel string, item ItemRef) error {

 // RemovePin un-pins an item from a channel
 func (api *Client) RemovePin(channel string, item ItemRef) error {
+	return api.RemovePinContext(context.Background(), channel, item)
+}
+
+// RemovePinContext un-pins an item from a channel with a custom context
+func (api *Client) RemovePinContext(ctx context.Context, channel string, item ItemRef) error {
 	values := url.Values{
 		"channel": {channel},
 		"token":   {api.config.token},
@ -52,7 +63,7 @@ func (api *Client) RemovePin(channel string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("pins.remove", values, response, api.debug); err != nil {
+	if err := post(ctx, "pins.remove", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -63,12 +74,17 @@ func (api *Client) RemovePin(channel string, item ItemRef) error {

 // ListPins returns information about the items a user reacted to.
 func (api *Client) ListPins(channel string) ([]Item, *Paging, error) {
+	return api.ListPinsContext(context.Background(), channel)
+}
+
+// ListPinsContext returns information about the items a user reacted to with a custom context.
+func (api *Client) ListPinsContext(ctx context.Context, channel string) ([]Item, *Paging, error) {
 	values := url.Values{
 		"channel": {channel},
 		"token":   {api.config.token},
 	}
 	response := &listPinsResponseFull{}
-	err := post("pins.list", values, response, api.debug)
+	err := post(ctx, "pins.list", values, response, api.debug)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/vendor/github.com/nlopes/slack/reactions.go
+++ b/vendor/github.com/nlopes/slack/reactions.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -129,6 +130,11 @@ func (res listReactionsResponseFull) extractReactedItems() []ReactedItem {

 // AddReaction adds a reaction emoji to a message, file or file comment.
 func (api *Client) AddReaction(name string, item ItemRef) error {
+	return api.AddReactionContext(context.Background(), name, item)
+}
+
+// AddReactionContext adds a reaction emoji to a message, file or file comment with a custom context.
+func (api *Client) AddReactionContext(ctx context.Context, name string, item ItemRef) error {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -148,7 +154,7 @@ func (api *Client) AddReaction(name string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("reactions.add", values, response, api.debug); err != nil {
+	if err := post(ctx, "reactions.add", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -159,6 +165,11 @@ func (api *Client) AddReaction(name string, item ItemRef) error {

 // RemoveReaction removes a reaction emoji from a message, file or file comment.
 func (api *Client) RemoveReaction(name string, item ItemRef) error {
+	return api.RemoveReactionContext(context.Background(), name, item)
+}
+
+// RemoveReactionContext removes a reaction emoji from a message, file or file comment with a custom context.
+func (api *Client) RemoveReactionContext(ctx context.Context, name string, item ItemRef) error {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -178,7 +189,7 @@ func (api *Client) RemoveReaction(name string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("reactions.remove", values, response, api.debug); err != nil {
+	if err := post(ctx, "reactions.remove", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -189,6 +200,11 @@ func (api *Client) RemoveReaction(name string, item ItemRef) error {

 // GetReactions returns details about the reactions on an item.
 func (api *Client) GetReactions(item ItemRef, params GetReactionsParameters) ([]ItemReaction, error) {
+	return api.GetReactionsContext(context.Background(), item, params)
+}
+
+// GetReactionsContext returns details about the reactions on an item with a custom context
+func (api *Client) GetReactionsContext(ctx context.Context, item ItemRef, params GetReactionsParameters) ([]ItemReaction, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -208,7 +224,7 @@ func (api *Client) GetReactions(item ItemRef, params GetReactionsParameters) ([]
 		values.Set("full", strconv.FormatBool(params.Full))
 	}
 	response := &getReactionsResponseFull{}
-	if err := post("reactions.get", values, response, api.debug); err != nil {
+	if err := post(ctx, "reactions.get", values, response, api.debug); err != nil {
 		return nil, err
 	}
 	if !response.Ok {
@ -219,6 +235,11 @@ func (api *Client) GetReactions(item ItemRef, params GetReactionsParameters) ([]

 // ListReactions returns information about the items a user reacted to.
 func (api *Client) ListReactions(params ListReactionsParameters) ([]ReactedItem, *Paging, error) {
+	return api.ListReactionsContext(context.Background(), params)
+}
+
+// ListReactionsContext returns information about the items a user reacted to with a custom context.
+func (api *Client) ListReactionsContext(ctx context.Context, params ListReactionsParameters) ([]ReactedItem, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -235,7 +256,7 @@ func (api *Client) ListReactions(params ListReactionsParameters) ([]ReactedItem,
 		values.Add("full", strconv.FormatBool(params.Full))
 	}
 	response := &listReactionsResponseFull{}
-	err := post("reactions.list", values, response, api.debug)
+	err := post(ctx, "reactions.list", values, response, api.debug)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/vendor/github.com/nlopes/slack/rtm.go
+++ b/vendor/github.com/nlopes/slack/rtm.go
@ -1,18 +1,58 @@
 package slack

 import (
+	"context"
+	"encoding/json"
 	"fmt"
 	"net/url"
+	"time"
 )

-// StartRTM calls the "rtm.start" endpoint and returns the provided URL and the full Info
-// block.
+// StartRTM calls the "rtm.start" endpoint and returns the provided URL and the full Info block.
 //
-// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()`
-// on it.
+// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
 func (api *Client) StartRTM() (info *Info, websocketURL string, err error) {
+	return api.StartRTMContext(context.Background())
+}
+
+// StartRTMContext calls the "rtm.start" endpoint and returns the provided URL and the full Info block with a custom context.
+//
+// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
+func (api *Client) StartRTMContext(ctx context.Context) (info *Info, websocketURL string, err error) {
 	response := &infoResponseFull{}
-	err = post("rtm.start", url.Values{"token": {api.config.token}}, response, api.debug)
+	err = post(ctx, "rtm.start", url.Values{"token": {api.config.token}}, response, api.debug)
+	if err != nil {
+		return nil, "", fmt.Errorf("post: %s", err)
+	}
+	if !response.Ok {
+		return nil, "", response.Error
+	}
+
+	// websocket.Dial does not accept url without the port (yet)
+	// Fixed by: https://github.com/golang/net/commit/5058c78c3627b31e484a81463acd51c7cecc06f3
+	// but slack returns the address with no port, so we have to fix it
+	api.Debugln("Using URL:", response.Info.URL)
+	websocketURL, err = websocketizeURLPort(response.Info.URL)
+	if err != nil {
+		return nil, "", fmt.Errorf("parsing response URL: %s", err)
+	}
+
+	return &response.Info, websocketURL, nil
+}
+
+// ConnectRTM calls the "rtm.connect" endpoint and returns the provided URL and the compact Info block.
+//
+// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
+func (api *Client) ConnectRTM() (info *Info, websocketURL string, err error) {
+	return api.ConnectRTMContext(context.Background())
+}
+
+// ConnectRTM calls the "rtm.connect" endpoint and returns the provided URL and the compact Info block with a custom context.
+//
+// To have a fully managed Websocket connection, use `NewRTM`, and call `ManageConnection()` on it.
+func (api *Client) ConnectRTMContext(ctx context.Context) (info *Info, websocketURL string, err error) {
+	response := &infoResponseFull{}
+	err = post(ctx, "rtm.connect", url.Values{"token": {api.config.token}}, response, api.debug)
 	if err != nil {
 		return nil, "", fmt.Errorf("post: %s", err)
 	}
@ -33,7 +73,33 @@ func (api *Client) StartRTM() (info *Info, websocketURL string, err error) {
 }

 // NewRTM returns a RTM, which provides a fully managed connection to
-// Slack's websocket-based Real-Time Messaging protocol./
+// Slack's websocket-based Real-Time Messaging protocol.
 func (api *Client) NewRTM() *RTM {
-	return newRTM(api)
+	return api.NewRTMWithOptions(nil)
+}
+
+// NewRTMWithOptions returns a RTM, which provides a fully managed connection to
+// Slack's websocket-based Real-Time Messaging protocol.
+// This also allows to configure various options available for RTM API.
+func (api *Client) NewRTMWithOptions(options *RTMOptions) *RTM {
+	result := &RTM{
+		Client:           *api,
+		IncomingEvents:   make(chan RTMEvent, 50),
+		outgoingMessages: make(chan OutgoingMessage, 20),
+		pings:            make(map[int]time.Time),
+		isConnected:      false,
+		wasIntentional:   true,
+		killChannel:      make(chan bool),
+		forcePing:        make(chan bool),
+		rawEvents:        make(chan json.RawMessage),
+		idGen:            NewSafeID(1),
+	}
+
+	if options != nil {
+		result.useRTMStart = options.UseRTMStart
+	} else {
+		result.useRTMStart = true
+	}
+
+	return result
 }
--- a/vendor/github.com/nlopes/slack/search.go
+++ b/vendor/github.com/nlopes/slack/search.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -80,7 +81,7 @@ func NewSearchParameters() SearchParameters {
 	}
 }

-func (api *Client) _search(path, query string, params SearchParameters, files, messages bool) (response *searchResponseFull, error error) {
+func (api *Client) _search(ctx context.Context, path, query string, params SearchParameters, files, messages bool) (response *searchResponseFull, error error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"query": {query},
@ -101,7 +102,7 @@ func (api *Client) _search(path, query string, params SearchParameters, files, m
 		values.Add("page", strconv.Itoa(params.Page))
 	}
 	response = &searchResponseFull{}
-	err := post(path, values, response, api.debug)
+	err := post(ctx, path, values, response, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -113,7 +114,11 @@ func (api *Client) _search(path, query string, params SearchParameters, files, m
 }

 func (api *Client) Search(query string, params SearchParameters) (*SearchMessages, *SearchFiles, error) {
-	response, err := api._search("search.all", query, params, true, true)
+	return api.SearchContext(context.Background(), query, params)
+}
+
+func (api *Client) SearchContext(ctx context.Context, query string, params SearchParameters) (*SearchMessages, *SearchFiles, error) {
+	response, err := api._search(ctx, "search.all", query, params, true, true)
 	if err != nil {
 		return nil, nil, err
 	}
@ -121,7 +126,11 @@ func (api *Client) Search(query string, params SearchParameters) (*SearchMessage
 }

 func (api *Client) SearchFiles(query string, params SearchParameters) (*SearchFiles, error) {
-	response, err := api._search("search.files", query, params, true, false)
+	return api.SearchFilesContext(context.Background(), query, params)
+}
+
+func (api *Client) SearchFilesContext(ctx context.Context, query string, params SearchParameters) (*SearchFiles, error) {
+	response, err := api._search(ctx, "search.files", query, params, true, false)
 	if err != nil {
 		return nil, err
 	}
@ -129,7 +138,11 @@ func (api *Client) SearchFiles(query string, params SearchParameters) (*SearchFi
 }

 func (api *Client) SearchMessages(query string, params SearchParameters) (*SearchMessages, error) {
-	response, err := api._search("search.messages", query, params, false, true)
+	return api.SearchMessagesContext(context.Background(), query, params)
+}
+
+func (api *Client) SearchMessagesContext(ctx context.Context, query string, params SearchParameters) (*SearchMessages, error) {
+	response, err := api._search(ctx, "search.messages", query, params, false, true)
 	if err != nil {
 		return nil, err
 	}
--- a/vendor/github.com/nlopes/slack/slack.go
+++ b/vendor/github.com/nlopes/slack/slack.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"log"
 	"net/url"
@ -54,8 +55,13 @@ func New(token string) *Client {

 // AuthTest tests if the user is able to do authenticated requests or not
 func (api *Client) AuthTest() (response *AuthTestResponse, error error) {
+	return api.AuthTestContext(context.Background())
+}
+
+// AuthTestContext tests if the user is able to do authenticated requests or not with a custom context
+func (api *Client) AuthTestContext(ctx context.Context) (response *AuthTestResponse, error error) {
 	responseFull := &authTestResponseFull{}
-	err := post("auth.test", url.Values{"token": {api.config.token}}, responseFull, api.debug)
+	err := post(ctx, "auth.test", url.Values{"token": {api.config.token}}, responseFull, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -71,7 +77,7 @@ func (api *Client) AuthTest() (response *AuthTestResponse, error error) {
 func (api *Client) SetDebug(debug bool) {
 	api.debug = debug
 	if debug && logger == nil {
-		logger = log.New(os.Stdout, "nlopes/slack", log.LstdFlags | log.Lshortfile)
+		logger = log.New(os.Stdout, "nlopes/slack", log.LstdFlags|log.Lshortfile)
 	}
 }

--- a/vendor/github.com/nlopes/slack/stars.go
+++ b/vendor/github.com/nlopes/slack/stars.go
@ -1,6 +1,7 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
@ -37,6 +38,11 @@ func NewStarsParameters() StarsParameters {

 // AddStar stars an item in a channel
 func (api *Client) AddStar(channel string, item ItemRef) error {
+	return api.AddStarContext(context.Background(), channel, item)
+}
+
+// AddStarContext stars an item in a channel with a custom context
+func (api *Client) AddStarContext(ctx context.Context, channel string, item ItemRef) error {
 	values := url.Values{
 		"channel": {channel},
 		"token":   {api.config.token},
@ -51,7 +57,7 @@ func (api *Client) AddStar(channel string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("stars.add", values, response, api.debug); err != nil {
+	if err := post(ctx, "stars.add", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -62,6 +68,11 @@ func (api *Client) AddStar(channel string, item ItemRef) error {

 // RemoveStar removes a starred item from a channel
 func (api *Client) RemoveStar(channel string, item ItemRef) error {
+	return api.RemoveStarContext(context.Background(), channel, item)
+}
+
+// RemoveStarContext removes a starred item from a channel with a custom context
+func (api *Client) RemoveStarContext(ctx context.Context, channel string, item ItemRef) error {
 	values := url.Values{
 		"channel": {channel},
 		"token":   {api.config.token},
@ -76,7 +87,7 @@ func (api *Client) RemoveStar(channel string, item ItemRef) error {
 		values.Set("file_comment", string(item.Comment))
 	}
 	response := &SlackResponse{}
-	if err := post("stars.remove", values, response, api.debug); err != nil {
+	if err := post(ctx, "stars.remove", values, response, api.debug); err != nil {
 		return err
 	}
 	if !response.Ok {
@ -87,6 +98,11 @@ func (api *Client) RemoveStar(channel string, item ItemRef) error {

 // ListStars returns information about the stars a user added
 func (api *Client) ListStars(params StarsParameters) ([]Item, *Paging, error) {
+	return api.ListStarsContext(context.Background(), params)
+}
+
+// ListStarsContext returns information about the stars a user added with a custom context
+func (api *Client) ListStarsContext(ctx context.Context, params StarsParameters) ([]Item, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -100,7 +116,7 @@ func (api *Client) ListStars(params StarsParameters) ([]Item, *Paging, error) {
 		values.Add("page", strconv.Itoa(params.Page))
 	}
 	response := &listResponseFull{}
-	err := post("stars.list", values, response, api.debug)
+	err := post(ctx, "stars.list", values, response, api.debug)
 	if err != nil {
 		return nil, nil, err
 	}
@ -110,7 +126,9 @@ func (api *Client) ListStars(params StarsParameters) ([]Item, *Paging, error) {
 	return response.Items, &response.Paging, nil
 }

-// GetStarred returns a list of StarredItem items. The user then has to iterate over them and figure out what they should
+// GetStarred returns a list of StarredItem items.
+//
+// The user then has to iterate over them and figure out what they should
 // be looking at according to what is in the Type.
 //    for _, item := range items {
 //        switch c.Type {
@ -123,7 +141,14 @@ func (api *Client) ListStars(params StarsParameters) ([]Item, *Paging, error) {
 // This function still exists to maintain backwards compatibility.
 // I exposed it as returning []StarredItem, so it shall stay as StarredItem
 func (api *Client) GetStarred(params StarsParameters) ([]StarredItem, *Paging, error) {
-	items, paging, err := api.ListStars(params)
+	return api.GetStarredContext(context.Background(), params)
+}
+
+// GetStarredContext returns a list of StarredItem items with a custom context
+//
+// For more details see GetStarred
+func (api *Client) GetStarredContext(ctx context.Context, params StarsParameters) ([]StarredItem, *Paging, error) {
+	items, paging, err := api.ListStarsContext(ctx, params)
 	if err != nil {
 		return nil, nil, err
 	}
--- a/vendor/github.com/nlopes/slack/team.go
+++ b/vendor/github.com/nlopes/slack/team.go
@ -1,14 +1,15 @@
 package slack

 import (
+	"context"
 	"errors"
 	"net/url"
 	"strconv"
 )

 const (
-	DEFAULT_LOGINS_COUNT   = 100
-	DEFAULT_LOGINS_PAGE    = 1
+	DEFAULT_LOGINS_COUNT = 100
+	DEFAULT_LOGINS_PAGE  = 1
 )

 type TeamResponse struct {
@ -26,11 +27,10 @@ type TeamInfo struct {

 type LoginResponse struct {
 	Logins []Login `json:"logins"`
-	Paging         `json:"paging"`
+	Paging `json:"paging"`
 	SlackResponse
 }

-
 type Login struct {
 	UserID    string `json:"user_id"`
 	Username  string `json:"username"`
@ -47,7 +47,6 @@ type Login struct {
 type BillableInfoResponse struct {
 	BillableInfo map[string]BillingActive `json:"billable_info"`
 	SlackResponse
-
 }

 type BillingActive struct {
@ -56,8 +55,8 @@ type BillingActive struct {

 // AccessLogParameters contains all the parameters necessary (including the optional ones) for a GetAccessLogs() request
 type AccessLogParameters struct {
-	Count         int
-	Page          int
+	Count int
+	Page  int
 }

 // NewAccessLogParameters provides an instance of AccessLogParameters with all the sane default values set
@ -68,10 +67,9 @@ func NewAccessLogParameters() AccessLogParameters {
 	}
 }

-
-func teamRequest(path string, values url.Values, debug bool) (*TeamResponse, error) {
+func teamRequest(ctx context.Context, path string, values url.Values, debug bool) (*TeamResponse, error) {
 	response := &TeamResponse{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -83,9 +81,9 @@ func teamRequest(path string, values url.Values, debug bool) (*TeamResponse, err
 	return response, nil
 }

-func billableInfoRequest(path string, values url.Values, debug bool) (map[string]BillingActive, error) {
+func billableInfoRequest(ctx context.Context, path string, values url.Values, debug bool) (map[string]BillingActive, error) {
 	response := &BillableInfoResponse{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -97,9 +95,9 @@ func billableInfoRequest(path string, values url.Values, debug bool) (map[string
 	return response.BillableInfo, nil
 }

-func accessLogsRequest(path string, values url.Values, debug bool) (*LoginResponse, error) {
+func accessLogsRequest(ctx context.Context, path string, values url.Values, debug bool) (*LoginResponse, error) {
 	response := &LoginResponse{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -109,14 +107,18 @@ func accessLogsRequest(path string, values url.Values, debug bool) (*LoginRespon
 	return response, nil
 }

-
 // GetTeamInfo gets the Team Information of the user
 func (api *Client) GetTeamInfo() (*TeamInfo, error) {
+	return api.GetTeamInfoContext(context.Background())
+}
+
+// GetTeamInfoContext gets the Team Information of the user with a custom context
+func (api *Client) GetTeamInfoContext(ctx context.Context) (*TeamInfo, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}

-	response, err := teamRequest("team.info", values, api.debug)
+	response, err := teamRequest(ctx, "team.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -125,6 +127,11 @@ func (api *Client) GetTeamInfo() (*TeamInfo, error) {

 // GetAccessLogs retrieves a page of logins according to the parameters given
 func (api *Client) GetAccessLogs(params AccessLogParameters) ([]Login, *Paging, error) {
+	return api.GetAccessLogsContext(context.Background(), params)
+}
+
+// GetAccessLogsContext retrieves a page of logins according to the parameters given with a custom context
+func (api *Client) GetAccessLogsContext(ctx context.Context, params AccessLogParameters) ([]Login, *Paging, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
@ -134,7 +141,7 @@ func (api *Client) GetAccessLogs(params AccessLogParameters) ([]Login, *Paging,
 	if params.Page != DEFAULT_LOGINS_PAGE {
 		values.Add("page", strconv.Itoa(params.Page))
 	}
-	response, err := accessLogsRequest("team.accessLogs", values, api.debug)
+	response, err := accessLogsRequest(ctx, "team.accessLogs", values, api.debug)
 	if err != nil {
 		return nil, nil, err
 	}
@ -142,19 +149,28 @@ func (api *Client) GetAccessLogs(params AccessLogParameters) ([]Login, *Paging,
 }

 func (api *Client) GetBillableInfo(user string) (map[string]BillingActive, error) {
+	return api.GetBillableInfoContext(context.Background(), user)
+}
+
+func (api *Client) GetBillableInfoContext(ctx context.Context, user string) (map[string]BillingActive, error) {
 	values := url.Values{
 		"token": {api.config.token},
-		"user": {user},
+		"user":  {user},
 	}

-	return billableInfoRequest("team.billableInfo", values, api.debug)
+	return billableInfoRequest(ctx, "team.billableInfo", values, api.debug)
 }

 // GetBillableInfoForTeam returns the billing_active status of all users on the team.
 func (api *Client) GetBillableInfoForTeam() (map[string]BillingActive, error) {
+	return api.GetBillableInfoForTeamContext(context.Background())
+}
+
+// GetBillableInfoForTeamContext returns the billing_active status of all users on the team with a custom context
+func (api *Client) GetBillableInfoForTeamContext(ctx context.Context) (map[string]BillingActive, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}

-	return billableInfoRequest("team.billableInfo", values, api.debug)
+	return billableInfoRequest(ctx, "team.billableInfo", values, api.debug)
 }
--- a/vendor/github.com/nlopes/slack/usergroups.go
+++ b/vendor/github.com/nlopes/slack/usergroups.go
@ -0,0 +1,210 @@
+package slack
+
+import (
+	"context"
+	"errors"
+	"net/url"
+	"strings"
+)
+
+// UserGroup contains all the information of a user group
+type UserGroup struct {
+	ID          string         `json:"id"`
+	TeamID      string         `json:"team_id"`
+	IsUserGroup bool           `json:"is_usergroup"`
+	Name        string         `json:"name"`
+	Description string         `json:"description"`
+	Handle      string         `json:"handle"`
+	IsExternal  bool           `json:"is_external"`
+	DateCreate  JSONTime       `json:"date_create"`
+	DateUpdate  JSONTime       `json:"date_update"`
+	DateDelete  JSONTime       `json:"date_delete"`
+	AutoType    string         `json:"auto_type"`
+	CreatedBy   string         `json:"created_by"`
+	UpdatedBy   string         `json:"updated_by"`
+	DeletedBy   string         `json:"deleted_by"`
+	Prefs       UserGroupPrefs `json:"prefs"`
+	UserCount   int            `json:"user_count"`
+}
+
+// UserGroupPrefs contains default channels and groups (private channels)
+type UserGroupPrefs struct {
+	Channels []string `json:"channels"`
+	Groups   []string `json:"groups"`
+}
+
+type userGroupResponseFull struct {
+	UserGroups []UserGroup `json:"usergroups"`
+	UserGroup  UserGroup   `json:"usergroup"`
+	Users      []string    `json:"users"`
+	SlackResponse
+}
+
+func userGroupRequest(ctx context.Context, path string, values url.Values, debug bool) (*userGroupResponseFull, error) {
+	response := &userGroupResponseFull{}
+	err := post(ctx, path, values, response, debug)
+	if err != nil {
+		return nil, err
+	}
+	if !response.Ok {
+		return nil, errors.New(response.Error)
+	}
+	return response, nil
+}
+
+// CreateUserGroup creates a new user group
+func (api *Client) CreateUserGroup(userGroup UserGroup) (UserGroup, error) {
+	return api.CreateUserGroupContext(context.Background(), userGroup)
+}
+
+// CreateUserGroupContext creates a new user group with a custom context
+func (api *Client) CreateUserGroupContext(ctx context.Context, userGroup UserGroup) (UserGroup, error) {
+	values := url.Values{
+		"token": {api.config.token},
+		"name":  {userGroup.Name},
+	}
+
+	if userGroup.Handle != "" {
+		values["handle"] = []string{userGroup.Handle}
+	}
+
+	if userGroup.Description != "" {
+		values["description"] = []string{userGroup.Description}
+	}
+
+	if len(userGroup.Prefs.Channels) > 0 {
+		values["channels"] = []string{strings.Join(userGroup.Prefs.Channels, ",")}
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.create", values, api.debug)
+	if err != nil {
+		return UserGroup{}, err
+	}
+	return response.UserGroup, nil
+}
+
+// DisableUserGroup disables an existing user group
+func (api *Client) DisableUserGroup(userGroup string) (UserGroup, error) {
+	return api.DisableUserGroupContext(context.Background(), userGroup)
+}
+
+// DisableUserGroupContext disables an existing user group with a custom context
+func (api *Client) DisableUserGroupContext(ctx context.Context, userGroup string) (UserGroup, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"usergroup": {userGroup},
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.disable", values, api.debug)
+	if err != nil {
+		return UserGroup{}, err
+	}
+	return response.UserGroup, nil
+}
+
+// EnableUserGroup enables an existing user group
+func (api *Client) EnableUserGroup(userGroup string) (UserGroup, error) {
+	return api.EnableUserGroupContext(context.Background(), userGroup)
+}
+
+// EnableUserGroupContext enables an existing user group with a custom context
+func (api *Client) EnableUserGroupContext(ctx context.Context, userGroup string) (UserGroup, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"usergroup": {userGroup},
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.enable", values, api.debug)
+	if err != nil {
+		return UserGroup{}, err
+	}
+	return response.UserGroup, nil
+}
+
+// GetUserGroups returns a list of user groups for the team
+func (api *Client) GetUserGroups() ([]UserGroup, error) {
+	return api.GetUserGroupsContext(context.Background())
+}
+
+// GetUserGroupsContext returns a list of user groups for the team with a custom context
+func (api *Client) GetUserGroupsContext(ctx context.Context) ([]UserGroup, error) {
+	values := url.Values{
+		"token": {api.config.token},
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.list", values, api.debug)
+	if err != nil {
+		return nil, err
+	}
+	return response.UserGroups, nil
+}
+
+// UpdateUserGroup will update an existing user group
+func (api *Client) UpdateUserGroup(userGroup UserGroup) (UserGroup, error) {
+	return api.UpdateUserGroupContext(context.Background(), userGroup)
+}
+
+// UpdateUserGroupContext will update an existing user group with a custom context
+func (api *Client) UpdateUserGroupContext(ctx context.Context, userGroup UserGroup) (UserGroup, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"usergroup": {userGroup.ID},
+	}
+
+	if userGroup.Name != "" {
+		values["name"] = []string{userGroup.Name}
+	}
+
+	if userGroup.Handle != "" {
+		values["handle"] = []string{userGroup.Handle}
+	}
+
+	if userGroup.Description != "" {
+		values["description"] = []string{userGroup.Description}
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.update", values, api.debug)
+	if err != nil {
+		return UserGroup{}, err
+	}
+	return response.UserGroup, nil
+}
+
+// GetUserGroupMembers will retrieve the current list of users in a group
+func (api *Client) GetUserGroupMembers(userGroup string) ([]string, error) {
+	return api.GetUserGroupMembersContext(context.Background(), userGroup)
+}
+
+// GetUserGroupMembersContext will retrieve the current list of users in a group with a custom context
+func (api *Client) GetUserGroupMembersContext(ctx context.Context, userGroup string) ([]string, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"usergroup": {userGroup},
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.users.list", values, api.debug)
+	if err != nil {
+		return []string{}, err
+	}
+	return response.Users, nil
+}
+
+// UpdateUserGroupMembers will update the members of an existing user group
+func (api *Client) UpdateUserGroupMembers(userGroup string, members string) (UserGroup, error) {
+	return api.UpdateUserGroupMembersContext(context.Background(), userGroup, members)
+}
+
+// UpdateUserGroupMembersContext will update the members of an existing user group with a custom context
+func (api *Client) UpdateUserGroupMembersContext(ctx context.Context, userGroup string, members string) (UserGroup, error) {
+	values := url.Values{
+		"token":     {api.config.token},
+		"usergroup": {userGroup},
+		"users":     {members},
+	}
+
+	response, err := userGroupRequest(ctx, "usergroups.users.update", values, api.debug)
+	if err != nil {
+		return UserGroup{}, err
+	}
+	return response.UserGroup, nil
+}
--- a/vendor/github.com/nlopes/slack/users.go
+++ b/vendor/github.com/nlopes/slack/users.go
@ -1,10 +1,18 @@
 package slack

 import (
+	"context"
+	"encoding/json"
 	"errors"
 	"net/url"
 )

+const (
+	DEFAULT_USER_PHOTO_CROP_X = -1
+	DEFAULT_USER_PHOTO_CROP_Y = -1
+	DEFAULT_USER_PHOTO_CROP_W = -1
+)
+
 // UserProfile contains all the information details of a given user
 type UserProfile struct {
 	FirstName          string `json:"first_name"`
@ -23,6 +31,8 @@ type UserProfile struct {
 	Title              string `json:"title"`
 	BotID              string `json:"bot_id,omitempty"`
 	ApiAppID           string `json:"api_app_id,omitempty"`
+	StatusText         string `json:"status_text,omitempty"`
+	StatusEmoji        string `json:"status_emoji,omitempty"`
 }

 // User contains all the information of a user
@ -97,9 +107,23 @@ type userResponseFull struct {
 	SlackResponse
 }

-func userRequest(path string, values url.Values, debug bool) (*userResponseFull, error) {
+type UserSetPhotoParams struct {
+	CropX int
+	CropY int
+	CropW int
+}
+
+func NewUserSetPhotoParams() UserSetPhotoParams {
+	return UserSetPhotoParams{
+		CropX: DEFAULT_USER_PHOTO_CROP_X,
+		CropY: DEFAULT_USER_PHOTO_CROP_Y,
+		CropW: DEFAULT_USER_PHOTO_CROP_W,
+	}
+}
+
+func userRequest(ctx context.Context, path string, values url.Values, debug bool) (*userResponseFull, error) {
 	response := &userResponseFull{}
-	err := post(path, values, response, debug)
+	err := post(ctx, path, values, response, debug)
 	if err != nil {
 		return nil, err
 	}
@ -111,11 +135,16 @@ func userRequest(path string, values url.Values, debug bool) (*userResponseFull,

 // GetUserPresence will retrieve the current presence status of given user.
 func (api *Client) GetUserPresence(user string) (*UserPresence, error) {
+	return api.GetUserPresenceContext(context.Background(), user)
+}
+
+// GetUserPresenceContext will retrieve the current presence status of given user with a custom context.
+func (api *Client) GetUserPresenceContext(ctx context.Context, user string) (*UserPresence, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"user":  {user},
 	}
-	response, err := userRequest("users.getPresence", values, api.debug)
+	response, err := userRequest(ctx, "users.getPresence", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -124,11 +153,16 @@ func (api *Client) GetUserPresence(user string) (*UserPresence, error) {

 // GetUserInfo will retrieve the complete user information
 func (api *Client) GetUserInfo(user string) (*User, error) {
+	return api.GetUserInfoContext(context.Background(), user)
+}
+
+// GetUserInfoContext will retrieve the complete user information with a custom context
+func (api *Client) GetUserInfoContext(ctx context.Context, user string) (*User, error) {
 	values := url.Values{
 		"token": {api.config.token},
 		"user":  {user},
 	}
-	response, err := userRequest("users.info", values, api.debug)
+	response, err := userRequest(ctx, "users.info", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -137,11 +171,16 @@ func (api *Client) GetUserInfo(user string) (*User, error) {

 // GetUsers returns the list of users (with their detailed information)
 func (api *Client) GetUsers() ([]User, error) {
+	return api.GetUsersContext(context.Background())
+}
+
+// GetUsersContext returns the list of users (with their detailed information) with a custom context
+func (api *Client) GetUsersContext(ctx context.Context) ([]User, error) {
 	values := url.Values{
 		"token":    {api.config.token},
 		"presence": {"1"},
 	}
-	response, err := userRequest("users.list", values, api.debug)
+	response, err := userRequest(ctx, "users.list", values, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -150,10 +189,15 @@ func (api *Client) GetUsers() ([]User, error) {

 // SetUserAsActive marks the currently authenticated user as active
 func (api *Client) SetUserAsActive() error {
+	return api.SetUserAsActiveContext(context.Background())
+}
+
+// SetUserAsActiveContext marks the currently authenticated user as active with a custom context
+func (api *Client) SetUserAsActiveContext(ctx context.Context) error {
 	values := url.Values{
 		"token": {api.config.token},
 	}
-	_, err := userRequest("users.setActive", values, api.debug)
+	_, err := userRequest(ctx, "users.setActive", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -162,11 +206,16 @@ func (api *Client) SetUserAsActive() error {

 // SetUserPresence changes the currently authenticated user presence
 func (api *Client) SetUserPresence(presence string) error {
+	return api.SetUserPresenceContext(context.Background(), presence)
+}
+
+// SetUserPresenceContext changes the currently authenticated user presence with a custom context
+func (api *Client) SetUserPresenceContext(ctx context.Context, presence string) error {
 	values := url.Values{
 		"token":    {api.config.token},
 		"presence": {presence},
 	}
-	_, err := userRequest("users.setPresence", values, api.debug)
+	_, err := userRequest(ctx, "users.setPresence", values, api.debug)
 	if err != nil {
 		return err
 	}
@ -176,11 +225,16 @@ func (api *Client) SetUserPresence(presence string) error {

 // GetUserIdentity will retrieve user info available per identity scopes
 func (api *Client) GetUserIdentity() (*UserIdentityResponse, error) {
+	return api.GetUserIdentityContext(context.Background())
+}
+
+// GetUserIdentityContext will retrieve user info available per identity scopes with a custom context
+func (api *Client) GetUserIdentityContext(ctx context.Context) (*UserIdentityResponse, error) {
 	values := url.Values{
 		"token": {api.config.token},
 	}
 	response := &UserIdentityResponse{}
-	err := post("users.identity", values, response, api.debug)
+	err := post(ctx, "users.identity", values, response, api.debug)
 	if err != nil {
 		return nil, err
 	}
@ -189,3 +243,120 @@ func (api *Client) GetUserIdentity() (*UserIdentityResponse, error) {
 	}
 	return response, nil
 }
+
+// SetUserPhoto changes the currently authenticated user's profile image
+func (api *Client) SetUserPhoto(ctx context.Context, image string, params UserSetPhotoParams) error {
+	return api.SetUserPhoto(context.Background(), image, params)
+}
+
+// SetUserPhotoContext changes the currently authenticated user's profile image using a custom context
+func (api *Client) SetUserPhotoContext(ctx context.Context, image string, params UserSetPhotoParams) error {
+	response := &SlackResponse{}
+	values := url.Values{
+		"token": {api.config.token},
+	}
+	if params.CropX != DEFAULT_USER_PHOTO_CROP_X {
+		values.Add("crop_x", string(params.CropX))
+	}
+	if params.CropY != DEFAULT_USER_PHOTO_CROP_Y {
+		values.Add("crop_y", string(params.CropY))
+	}
+	if params.CropW != DEFAULT_USER_PHOTO_CROP_W {
+		values.Add("crop_w", string(params.CropW))
+	}
+	err := postLocalWithMultipartResponse(ctx, "users.setPhoto", image, "image", values, response, api.debug)
+	if err != nil {
+		return err
+	}
+	if !response.Ok {
+		return errors.New(response.Error)
+	}
+	return nil
+}
+
+// DeleteUserPhoto deletes the current authenticated user's profile image
+func (api *Client) DeleteUserPhoto() error {
+	return api.DeleteUserPhotoContext(context.Background())
+}
+
+// DeleteUserPhotoContext deletes the current authenticated user's profile image with a custom context
+func (api *Client) DeleteUserPhotoContext(ctx context.Context) error {
+	response := &SlackResponse{}
+	values := url.Values{
+		"token": {api.config.token},
+	}
+	err := post(ctx, "users.deletePhoto", values, response, api.debug)
+	if err != nil {
+		return err
+	}
+	if !response.Ok {
+		return errors.New(response.Error)
+	}
+	return nil
+}
+
+// SetUserCustomStatus will set a custom status and emoji for the currently
+// authenticated user. If statusEmoji is "" and statusText is not, the Slack API
+// will automatically set it to ":speech_balloon:". Otherwise, if both are ""
+// the Slack API will unset the custom status/emoji.
+func (api *Client) SetUserCustomStatus(statusText, statusEmoji string) error {
+	return api.SetUserCustomStatusContext(context.Background(), statusText, statusEmoji)
+}
+
+// SetUserCustomStatusContext will set a custom status and emoji for the currently authenticated user with a custom context
+//
+// For more information see SetUserCustomStatus
+func (api *Client) SetUserCustomStatusContext(ctx context.Context, statusText, statusEmoji string) error {
+	// XXX(theckman): this anonymous struct is for making requests to the Slack
+	// API for setting and unsetting a User's Custom Status/Emoji. To change
+	// these values we must provide a JSON document as the profile POST field.
+	//
+	// We use an anonymous struct over UserProfile because to unset the values
+	// on the User's profile we cannot use the `json:"omitempty"` tag. This is
+	// because an empty string ("") is what's used to unset the values. Check
+	// out the API docs for more details:
+	//
+	// - https://api.slack.com/docs/presence-and-status#custom_status
+	profile, err := json.Marshal(
+		&struct {
+			StatusText  string `json:"status_text"`
+			StatusEmoji string `json:"status_emoji"`
+		}{
+			StatusText:  statusText,
+			StatusEmoji: statusEmoji,
+		},
+	)
+
+	if err != nil {
+		return err
+	}
+
+	values := url.Values{
+		"token":   {api.config.token},
+		"profile": {string(profile)},
+	}
+
+	response := &userResponseFull{}
+
+	if err = post(ctx, "users.profile.set", values, response, api.debug); err != nil {
+		return err
+	}
+
+	if !response.Ok {
+		return errors.New(response.Error)
+	}
+
+	return nil
+}
+
+// UnsetUserCustomStatus removes the custom status message for the currently
+// authenticated user. This is a convenience method that wraps (*Client).SetUserCustomStatus().
+func (api *Client) UnsetUserCustomStatus() error {
+	return api.UnsetUserCustomStatusContext(context.Background())
+}
+
+// UnsetUserCustomStatusContext removes the custom status message for the currently authenticated user
+// with a custom context. This is a convenience method that wraps (*Client).SetUserCustomStatus().
+func (api *Client) UnsetUserCustomStatusContext(ctx context.Context) error {
+	return api.SetUserCustomStatusContext(ctx, "", "")
+}
--- a/vendor/github.com/nlopes/slack/websocket.go
+++ b/vendor/github.com/nlopes/slack/websocket.go
@ -17,7 +17,7 @@ const (
 // RTM represents a managed websocket connection. It also supports
 // all the methods of the `Client` type.
 //
-// Create this element with Client's NewRTM().
+// Create this element with Client's NewRTM() or NewRTMWithOptions(*RTMOptions)
 type RTM struct {
 	idGen IDGenerator
 	pings map[int]time.Time
@ -38,23 +38,23 @@ type RTM struct {

 	// UserDetails upon connection
 	info *Info
+
+	// useRTMStart should be set to true if you want to use
+	// rtm.start to connect to Slack, otherwise it will use
+	// rtm.connect
+	useRTMStart bool
 }

-// NewRTM returns a RTM, which provides a fully managed connection to
-// Slack's websocket-based Real-Time Messaging protocol.
-func newRTM(api *Client) *RTM {
-	return &RTM{
-		Client:           *api,
-		IncomingEvents:   make(chan RTMEvent, 50),
-		outgoingMessages: make(chan OutgoingMessage, 20),
-		pings:            make(map[int]time.Time),
-		isConnected:      false,
-		wasIntentional:   true,
-		killChannel:      make(chan bool),
-		forcePing:        make(chan bool),
-		rawEvents:        make(chan json.RawMessage),
-		idGen:            NewSafeID(1),
-	}
+// RTMOptions allows configuration of various options available for RTM messaging
+//
+// This structure will evolve in time so please make sure you are always using the
+// named keys for every entry available as per Go 1 compatibility promise adding fields
+// to this structure should not be considered a breaking change.
+type RTMOptions struct {
+	// UseRTMStart set to true in order to use rtm.start or false to use rtm.connect
+	// As of 11th July 2017 you should prefer setting this to false, see:
+	// https://api.slack.com/changelog/2017-04-start-using-rtm-connect-and-stop-using-rtm-start
+	UseRTMStart bool
 }

 // Disconnect and wait, blocking until a successful disconnection.
--- a/vendor/github.com/nlopes/slack/websocket_managed_conn.go
+++ b/vendor/github.com/nlopes/slack/websocket_managed_conn.go
@ -29,7 +29,7 @@ func (rtm *RTM) ManageConnection() {
 		connectionCount++
 		// start trying to connect
 		// the returned err is already passed onto the IncomingEvents channel
-		info, conn, err := rtm.connect(connectionCount)
+		info, conn, err := rtm.connect(connectionCount, rtm.useRTMStart)
 		// if err != nil then the connection is sucessful - otherwise it is
 		// fatal
 		if err != nil {
@ -64,7 +64,9 @@ func (rtm *RTM) ManageConnection() {
 // connect attempts to connect to the slack websocket API. It handles any
 // errors that occur while connecting and will return once a connection
 // has been successfully opened.
-func (rtm *RTM) connect(connectionCount int) (*Info, *websocket.Conn, error) {
+// If useRTMStart is false then it uses rtm.connect to create the connection,
+// otherwise it uses rtm.start.
+func (rtm *RTM) connect(connectionCount int, useRTMStart bool) (*Info, *websocket.Conn, error) {
 	// used to provide exponential backoff wait time with jitter before trying
 	// to connect to slack again
 	boff := &backoff{
@ -81,7 +83,7 @@ func (rtm *RTM) connect(connectionCount int) (*Info, *websocket.Conn, error) {
 			ConnectionCount: connectionCount,
 		}}
 		// attempt to start the connection
-		info, conn, err := rtm.startRTMAndDial()
+		info, conn, err := rtm.startRTMAndDial(useRTMStart)
 		if err == nil {
 			return info, conn, nil
 		}
@ -105,10 +107,19 @@ func (rtm *RTM) connect(connectionCount int) (*Info, *websocket.Conn, error) {
 	}
 }

-// startRTMAndDial attemps to connect to the slack websocket. It returns the
-// full information returned by the "rtm.start" method on the slack API.
-func (rtm *RTM) startRTMAndDial() (*Info, *websocket.Conn, error) {
-	info, url, err := rtm.StartRTM()
+// startRTMAndDial attempts to connect to the slack websocket. If useRTMStart is true,
+// then it returns the  full information returned by the "rtm.start" method on the
+// slack API. Else it uses the "rtm.connect" method to connect
+func (rtm *RTM) startRTMAndDial(useRTMStart bool) (*Info, *websocket.Conn, error) {
+	var info *Info
+	var url string
+	var err error
+
+	if useRTMStart {
+		info, url, err = rtm.StartRTM()
+	} else {
+		info, url, err = rtm.ConnectRTM()
+	}
 	if err != nil {
 		return nil, nil, err
 	}
--- a/vendor/github.com/nlopes/slack/websocket_misc.go
+++ b/vendor/github.com/nlopes/slack/websocket_misc.go
@ -76,8 +76,12 @@ type UserChangeEvent struct {

 // EmojiChangedEvent represents the emoji changed event
 type EmojiChangedEvent struct {
-	Type           string `json:"type"`
-	EventTimestamp string `json:"event_ts"`
+	Type           string   `json:"type"`
+	SubType        string   `json:"subtype"`
+	Name           string   `json:"name"`
+	Names          []string `json:"names"`
+	Value          string   `json:"value"` 
+	EventTimestamp string   `json:"event_ts"`
 }

 // CommandsChangedEvent represents the commands changed event
--- a/vendor/github.com/stretchr/testify/assert/LICENCE.txt
+++ b/vendor/github.com/stretchr/testify/assert/LICENCE.txt
@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/stretchr/testify/assert/LICENSE
+++ b/vendor/github.com/stretchr/testify/assert/LICENSE
@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/stretchr/testify/assert/assertion_format.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_format.go
@ -0,0 +1,379 @@
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+ */
+
+package assert
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Conditionf uses a Comparison to assert a complex condition.
+func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool {
+	return Condition(t, comp, append([]interface{}{msg}, args...)...)
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//    assert.Containsf(t, "Hello World", "World", "error message %s", "formatted")
+//    assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted")
+//    assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	return Contains(t, s, contains, append([]interface{}{msg}, args...)...)
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  assert.Emptyf(t, obj, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	return Empty(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// Equalf asserts that two objects are equal.
+//
+//    assert.Equalf(t, 123, 123, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return Equal(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   assert.EqualErrorf(t, err,  expectedErrorString, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool {
+	return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...)
+}
+
+// EqualValuesf asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.Errorf(t, err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedErrorf, err)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Errorf(t TestingT, err error, msg string, args ...interface{}) bool {
+	return Error(t, err, append([]interface{}{msg}, args...)...)
+}
+
+// Exactlyf asserts that two objects are equal is value and type.
+//
+//    assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Failf reports a failure through
+func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
+	return Fail(t, failureMessage, append([]interface{}{msg}, args...)...)
+}
+
+// FailNowf fails test
+func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool {
+	return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...)
+}
+
+// Falsef asserts that the specified value is false.
+//
+//    assert.Falsef(t, myBool, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool {
+	return False(t, value, append([]interface{}{msg}, args...)...)
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//  assert.HTTPBodyContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyContains(t, handler, method, url, values, str)
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  assert.HTTPBodyNotContainsf(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyNotContains(t, handler, method, url, values, str)
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//  assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
+func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPError(t, handler, method, url, values)
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//  assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
+func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPRedirect(t, handler, method, url, values)
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//  assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPSuccess(t, handler, method, url, values)
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//    assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject))
+func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...)
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+// 	 assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...)
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
+	return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...)
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//  assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool {
+	return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//    assert.Lenf(t, mySlice, 3, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool {
+	return Len(t, object, length, append([]interface{}{msg}, args...)...)
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//    assert.Nilf(t, err, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	return Nil(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if assert.NoErrorf(t, err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedObj, actualObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool {
+	return NoError(t, err, append([]interface{}{msg}, args...)...)
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//    assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted")
+//    assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted")
+//    assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	return NotContains(t, s, contains, append([]interface{}{msg}, args...)...)
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  if assert.NotEmptyf(t, obj, "error message %s", "formatted") {
+//    assert.Equal(t, "two", obj[1])
+//  }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	return NotEmpty(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//    assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...)
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//    assert.NotNilf(t, err, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool {
+	return NotNil(t, object, append([]interface{}{msg}, args...)...)
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
+	return NotPanics(t, f, append([]interface{}{msg}, args...)...)
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//  assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
+//  assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...)
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) contains not all
+// elements given in the specified subset(array, slice...).
+//
+//    assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...)
+}
+
+// NotZerof asserts that i is not the zero value for its type and returns the truth.
+func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
+	return NotZero(t, i, append([]interface{}{msg}, args...)...)
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//   assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool {
+	return Panics(t, f, append([]interface{}{msg}, args...)...)
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//   assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
+	return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...)
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//  assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
+//  assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	return Regexp(t, rx, str, append([]interface{}{msg}, args...)...)
+}
+
+// Subsetf asserts that the specified list(array, slice...) contains all
+// elements given in the specified subset(array, slice...).
+//
+//    assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	return Subset(t, list, subset, append([]interface{}{msg}, args...)...)
+}
+
+// Truef asserts that the specified value is true.
+//
+//    assert.Truef(t, myBool, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func Truef(t TestingT, value bool, msg string, args ...interface{}) bool {
+	return True(t, value, append([]interface{}{msg}, args...)...)
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//   assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
+	return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...)
+}
+
+// Zerof asserts that i is the zero value for its type and returns the truth.
+func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool {
+	return Zero(t, i, append([]interface{}{msg}, args...)...)
+}
--- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go
+++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go
@ -0,0 +1,746 @@
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen
+* THIS FILE MUST NOT BE EDITED BY HAND
+ */
+
+package assert
+
+import (
+	http "net/http"
+	url "net/url"
+	time "time"
+)
+
+// Condition uses a Comparison to assert a complex condition.
+func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool {
+	return Condition(a.t, comp, msgAndArgs...)
+}
+
+// Conditionf uses a Comparison to assert a complex condition.
+func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool {
+	return Conditionf(a.t, comp, msg, args...)
+}
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//    a.Contains("Hello World", "World")
+//    a.Contains(["Hello", "World"], "World")
+//    a.Contains({"Hello": "World"}, "Hello")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
+	return Contains(a.t, s, contains, msgAndArgs...)
+}
+
+// Containsf asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//    a.Containsf("Hello World", "World", "error message %s", "formatted")
+//    a.Containsf(["Hello", "World"], "World", "error message %s", "formatted")
+//    a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	return Containsf(a.t, s, contains, msg, args...)
+}
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  a.Empty(obj)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool {
+	return Empty(a.t, object, msgAndArgs...)
+}
+
+// Emptyf asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  a.Emptyf(obj, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool {
+	return Emptyf(a.t, object, msg, args...)
+}
+
+// Equal asserts that two objects are equal.
+//
+//    a.Equal(123, 123)
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	return Equal(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualError asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   a.EqualError(err,  expectedErrorString)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool {
+	return EqualError(a.t, theError, errString, msgAndArgs...)
+}
+
+// EqualErrorf asserts that a function returned an error (i.e. not `nil`)
+// and that it is equal to the provided error.
+//
+//   actualObj, err := SomeFunction()
+//   a.EqualErrorf(err,  expectedErrorString, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool {
+	return EqualErrorf(a.t, theError, errString, msg, args...)
+}
+
+// EqualValues asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    a.EqualValues(uint32(123), int32(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	return EqualValues(a.t, expected, actual, msgAndArgs...)
+}
+
+// EqualValuesf asserts that two objects are equal or convertable to the same types
+// and equal.
+//
+//    a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return EqualValuesf(a.t, expected, actual, msg, args...)
+}
+
+// Equalf asserts that two objects are equal.
+//
+//    a.Equalf(123, 123, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return Equalf(a.t, expected, actual, msg, args...)
+}
+
+// Error asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.Error(err) {
+// 	   assert.Equal(t, expectedError, err)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool {
+	return Error(a.t, err, msgAndArgs...)
+}
+
+// Errorf asserts that a function returned an error (i.e. not `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.Errorf(err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedErrorf, err)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool {
+	return Errorf(a.t, err, msg, args...)
+}
+
+// Exactly asserts that two objects are equal is value and type.
+//
+//    a.Exactly(int32(123), int64(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	return Exactly(a.t, expected, actual, msgAndArgs...)
+}
+
+// Exactlyf asserts that two objects are equal is value and type.
+//
+//    a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123))
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return Exactlyf(a.t, expected, actual, msg, args...)
+}
+
+// Fail reports a failure through
+func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool {
+	return Fail(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNow fails test
+func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool {
+	return FailNow(a.t, failureMessage, msgAndArgs...)
+}
+
+// FailNowf fails test
+func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool {
+	return FailNowf(a.t, failureMessage, msg, args...)
+}
+
+// Failf reports a failure through
+func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool {
+	return Failf(a.t, failureMessage, msg, args...)
+}
+
+// False asserts that the specified value is false.
+//
+//    a.False(myBool)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool {
+	return False(a.t, value, msgAndArgs...)
+}
+
+// Falsef asserts that the specified value is false.
+//
+//    a.Falsef(myBool, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool {
+	return Falsef(a.t, value, msg, args...)
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyContains(a.t, handler, method, url, values, str)
+}
+
+// HTTPBodyContainsf asserts that a specified handler returns a
+// body that contains a string.
+//
+//  a.HTTPBodyContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyContainsf(a.t, handler, method, url, values, str)
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyNotContains(a.t, handler, method, url, values, str)
+}
+
+// HTTPBodyNotContainsf asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  a.HTTPBodyNotContainsf(myHandler, "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool {
+	return HTTPBodyNotContainsf(a.t, handler, method, url, values, str)
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPError(a.t, handler, method, url, values)
+}
+
+// HTTPErrorf asserts that a specified handler returns an error status code.
+//
+//  a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
+func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPErrorf(a.t, handler, method, url, values)
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPRedirect(a.t, handler, method, url, values)
+}
+
+// HTTPRedirectf asserts that a specified handler returns a redirect status code.
+//
+//  a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false).
+func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPRedirectf(a.t, handler, method, url, values)
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPSuccess(a.t, handler, method, url, values)
+}
+
+// HTTPSuccessf asserts that a specified handler returns a success status code.
+//
+//  a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values) bool {
+	return HTTPSuccessf(a.t, handler, method, url, values)
+}
+
+// Implements asserts that an object is implemented by the specified interface.
+//
+//    a.Implements((*MyInterface)(nil), new(MyObject))
+func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	return Implements(a.t, interfaceObject, object, msgAndArgs...)
+}
+
+// Implementsf asserts that an object is implemented by the specified interface.
+//
+//    a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject))
+func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool {
+	return Implementsf(a.t, interfaceObject, object, msg, args...)
+}
+
+// InDelta asserts that the two numerals are within delta of each other.
+//
+// 	 a.InDelta(math.Pi, (22 / 7.0), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	return InDelta(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaSlice is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool {
+	return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// InDeltaSlicef is the same as InDelta, except it compares two slices.
+func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	return InDeltaSlicef(a.t, expected, actual, delta, msg, args...)
+}
+
+// InDeltaf asserts that the two numerals are within delta of each other.
+//
+// 	 a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool {
+	return InDeltaf(a.t, expected, actual, delta, msg, args...)
+}
+
+// InEpsilon asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool {
+	return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...)
+}
+
+// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices.
+func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// InEpsilonf asserts that expected and actual have a relative error less than epsilon
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool {
+	return InEpsilonf(a.t, expected, actual, epsilon, msg, args...)
+}
+
+// IsType asserts that the specified objects are of the same type.
+func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool {
+	return IsType(a.t, expectedType, object, msgAndArgs...)
+}
+
+// IsTypef asserts that the specified objects are of the same type.
+func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool {
+	return IsTypef(a.t, expectedType, object, msg, args...)
+}
+
+// JSONEq asserts that two JSON strings are equivalent.
+//
+//  a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool {
+	return JSONEq(a.t, expected, actual, msgAndArgs...)
+}
+
+// JSONEqf asserts that two JSON strings are equivalent.
+//
+//  a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool {
+	return JSONEqf(a.t, expected, actual, msg, args...)
+}
+
+// Len asserts that the specified object has specific length.
+// Len also fails if the object has a type that len() not accept.
+//
+//    a.Len(mySlice, 3)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool {
+	return Len(a.t, object, length, msgAndArgs...)
+}
+
+// Lenf asserts that the specified object has specific length.
+// Lenf also fails if the object has a type that len() not accept.
+//
+//    a.Lenf(mySlice, 3, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool {
+	return Lenf(a.t, object, length, msg, args...)
+}
+
+// Nil asserts that the specified object is nil.
+//
+//    a.Nil(err)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool {
+	return Nil(a.t, object, msgAndArgs...)
+}
+
+// Nilf asserts that the specified object is nil.
+//
+//    a.Nilf(err, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool {
+	return Nilf(a.t, object, msg, args...)
+}
+
+// NoError asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.NoError(err) {
+// 	   assert.Equal(t, expectedObj, actualObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool {
+	return NoError(a.t, err, msgAndArgs...)
+}
+
+// NoErrorf asserts that a function returned no error (i.e. `nil`).
+//
+//   actualObj, err := SomeFunction()
+//   if a.NoErrorf(err, "error message %s", "formatted") {
+// 	   assert.Equal(t, expectedObj, actualObj)
+//   }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool {
+	return NoErrorf(a.t, err, msg, args...)
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//    a.NotContains("Hello World", "Earth")
+//    a.NotContains(["Hello", "World"], "Earth")
+//    a.NotContains({"Hello": "World"}, "Earth")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool {
+	return NotContains(a.t, s, contains, msgAndArgs...)
+}
+
+// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//    a.NotContainsf("Hello World", "Earth", "error message %s", "formatted")
+//    a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted")
+//    a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool {
+	return NotContainsf(a.t, s, contains, msg, args...)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  if a.NotEmpty(obj) {
+//    assert.Equal(t, "two", obj[1])
+//  }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool {
+	return NotEmpty(a.t, object, msgAndArgs...)
+}
+
+// NotEmptyf asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//  if a.NotEmptyf(obj, "error message %s", "formatted") {
+//    assert.Equal(t, "two", obj[1])
+//  }
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool {
+	return NotEmptyf(a.t, object, msg, args...)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//    a.NotEqual(obj1, obj2)
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool {
+	return NotEqual(a.t, expected, actual, msgAndArgs...)
+}
+
+// NotEqualf asserts that the specified values are NOT equal.
+//
+//    a.NotEqualf(obj1, obj2, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool {
+	return NotEqualf(a.t, expected, actual, msg, args...)
+}
+
+// NotNil asserts that the specified object is not nil.
+//
+//    a.NotNil(err)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool {
+	return NotNil(a.t, object, msgAndArgs...)
+}
+
+// NotNilf asserts that the specified object is not nil.
+//
+//    a.NotNilf(err, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool {
+	return NotNilf(a.t, object, msg, args...)
+}
+
+// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   a.NotPanics(func(){ RemainCalm() })
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	return NotPanics(a.t, f, msgAndArgs...)
+}
+
+// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic.
+//
+//   a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
+	return NotPanicsf(a.t, f, msg, args...)
+}
+
+// NotRegexp asserts that a specified regexp does not match a string.
+//
+//  a.NotRegexp(regexp.MustCompile("starts"), "it's starting")
+//  a.NotRegexp("^start", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	return NotRegexp(a.t, rx, str, msgAndArgs...)
+}
+
+// NotRegexpf asserts that a specified regexp does not match a string.
+//
+//  a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting")
+//  a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	return NotRegexpf(a.t, rx, str, msg, args...)
+}
+
+// NotSubset asserts that the specified list(array, slice...) contains not all
+// elements given in the specified subset(array, slice...).
+//
+//    a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
+	return NotSubset(a.t, list, subset, msgAndArgs...)
+}
+
+// NotSubsetf asserts that the specified list(array, slice...) contains not all
+// elements given in the specified subset(array, slice...).
+//
+//    a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	return NotSubsetf(a.t, list, subset, msg, args...)
+}
+
+// NotZero asserts that i is not the zero value for its type and returns the truth.
+func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool {
+	return NotZero(a.t, i, msgAndArgs...)
+}
+
+// NotZerof asserts that i is not the zero value for its type and returns the truth.
+func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool {
+	return NotZerof(a.t, i, msg, args...)
+}
+
+// Panics asserts that the code inside the specified PanicTestFunc panics.
+//
+//   a.Panics(func(){ GoCrazy() })
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	return Panics(a.t, f, msgAndArgs...)
+}
+
+// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//   a.PanicsWithValue("crazy error", func(){ GoCrazy() })
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool {
+	return PanicsWithValue(a.t, expected, f, msgAndArgs...)
+}
+
+// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that
+// the recovered panic value equals the expected panic value.
+//
+//   a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool {
+	return PanicsWithValuef(a.t, expected, f, msg, args...)
+}
+
+// Panicsf asserts that the code inside the specified PanicTestFunc panics.
+//
+//   a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool {
+	return Panicsf(a.t, f, msg, args...)
+}
+
+// Regexp asserts that a specified regexp matches a string.
+//
+//  a.Regexp(regexp.MustCompile("start"), "it's starting")
+//  a.Regexp("start...$", "it's not starting")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool {
+	return Regexp(a.t, rx, str, msgAndArgs...)
+}
+
+// Regexpf asserts that a specified regexp matches a string.
+//
+//  a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting")
+//  a.Regexpf("start...$", "it's not starting", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool {
+	return Regexpf(a.t, rx, str, msg, args...)
+}
+
+// Subset asserts that the specified list(array, slice...) contains all
+// elements given in the specified subset(array, slice...).
+//
+//    a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool {
+	return Subset(a.t, list, subset, msgAndArgs...)
+}
+
+// Subsetf asserts that the specified list(array, slice...) contains all
+// elements given in the specified subset(array, slice...).
+//
+//    a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool {
+	return Subsetf(a.t, list, subset, msg, args...)
+}
+
+// True asserts that the specified value is true.
+//
+//    a.True(myBool)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool {
+	return True(a.t, value, msgAndArgs...)
+}
+
+// Truef asserts that the specified value is true.
+//
+//    a.Truef(myBool, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool {
+	return Truef(a.t, value, msg, args...)
+}
+
+// WithinDuration asserts that the two times are within duration delta of each other.
+//
+//   a.WithinDuration(time.Now(), time.Now(), 10*time.Second)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool {
+	return WithinDuration(a.t, expected, actual, delta, msgAndArgs...)
+}
+
+// WithinDurationf asserts that the two times are within duration delta of each other.
+//
+//   a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool {
+	return WithinDurationf(a.t, expected, actual, delta, msg, args...)
+}
+
+// Zero asserts that i is the zero value for its type and returns the truth.
+func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool {
+	return Zero(a.t, i, msgAndArgs...)
+}
+
+// Zerof asserts that i is the zero value for its type and returns the truth.
+func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool {
+	return Zerof(a.t, i, msg, args...)
+}
--- a/vendor/github.com/stretchr/testify/assert/assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/assertions.go
--- a/vendor/github.com/stretchr/testify/assert/doc.go
+++ b/vendor/github.com/stretchr/testify/assert/doc.go
@ -0,0 +1,45 @@
+// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.
+//
+// Example Usage
+//
+// The following is a complete example using assert in a standard test function:
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
+//
+//    func TestSomething(t *testing.T) {
+//
+//      var a string = "Hello"
+//      var b string = "Hello"
+//
+//      assert.Equal(t, a, b, "The two words should be the same.")
+//
+//    }
+//
+// if you assert many times, use the format below:
+//
+//    import (
+//      "testing"
+//      "github.com/stretchr/testify/assert"
+//    )
+//
+//    func TestSomething(t *testing.T) {
+//      assert := assert.New(t)
+//
+//      var a string = "Hello"
+//      var b string = "Hello"
+//
+//      assert.Equal(a, b, "The two words should be the same.")
+//    }
+//
+// Assertions
+//
+// Assertions allow you to easily write test code, and are global funcs in the `assert` package.
+// All assertion functions take, as the first argument, the `*testing.T` object provided by the
+// testing framework. This allows the assertion funcs to write the failings and other details to
+// the correct place.
+//
+// Every assertion function also takes an optional string message as the final argument,
+// allowing custom error messages to be appended to the message the assertion method outputs.
+package assert
--- a/vendor/github.com/stretchr/testify/assert/errors.go
+++ b/vendor/github.com/stretchr/testify/assert/errors.go
@ -0,0 +1,10 @@
+package assert
+
+import (
+	"errors"
+)
+
+// AnError is an error instance useful for testing.  If the code does not care
+// about error specifics, and only needs to return the error for example, this
+// error should be used to make the test code more readable.
+var AnError = errors.New("assert.AnError general error for testing")
--- a/vendor/github.com/stretchr/testify/assert/forward_assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/forward_assertions.go
@ -0,0 +1,16 @@
+package assert
+
+// Assertions provides assertion methods around the
+// TestingT interface.
+type Assertions struct {
+	t TestingT
+}
+
+// New makes a new Assertions object for the specified TestingT.
+func New(t TestingT) *Assertions {
+	return &Assertions{
+		t: t,
+	}
+}
+
+//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs
--- a/vendor/github.com/stretchr/testify/assert/http_assertions.go
+++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go
@ -0,0 +1,127 @@
+package assert
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+)
+
+// httpCode is a helper that returns HTTP code of the response. It returns -1 and
+// an error if building a new request fails.
+func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) {
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
+	if err != nil {
+		return -1, err
+	}
+	handler(w, req)
+	return w.Code, nil
+}
+
+// HTTPSuccess asserts that a specified handler returns a success status code.
+//
+//  assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil)
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		return false
+	}
+
+	isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent
+	if !isSuccessCode {
+		Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code))
+	}
+
+	return isSuccessCode
+}
+
+// HTTPRedirect asserts that a specified handler returns a redirect status code.
+//
+//  assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		return false
+	}
+
+	isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect
+	if !isRedirectCode {
+		Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code))
+	}
+
+	return isRedirectCode
+}
+
+// HTTPError asserts that a specified handler returns an error status code.
+//
+//  assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values) bool {
+	code, err := httpCode(handler, method, url, values)
+	if err != nil {
+		Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err))
+		return false
+	}
+
+	isErrorCode := code >= http.StatusBadRequest
+	if !isErrorCode {
+		Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code))
+	}
+
+	return isErrorCode
+}
+
+// HTTPBody is a helper that returns HTTP body of the response. It returns
+// empty string if building a new request fails.
+func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string {
+	w := httptest.NewRecorder()
+	req, err := http.NewRequest(method, url+"?"+values.Encode(), nil)
+	if err != nil {
+		return ""
+	}
+	handler(w, req)
+	return w.Body.String()
+}
+
+// HTTPBodyContains asserts that a specified handler returns a
+// body that contains a string.
+//
+//  assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
+	body := HTTPBody(handler, method, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if !contains {
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+	}
+
+	return contains
+}
+
+// HTTPBodyNotContains asserts that a specified handler returns a
+// body that does not contain a string.
+//
+//  assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")
+//
+// Returns whether the assertion was successful (true) or not (false).
+func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}) bool {
+	body := HTTPBody(handler, method, url, values)
+
+	contains := strings.Contains(body, fmt.Sprint(str))
+	if contains {
+		Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body))
+	}
+
+	return !contains
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/LICENCE.txt
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/LICENCE.txt
@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/LICENSE
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/LICENSE
@ -0,0 +1,22 @@
+Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell
+
+Please consider promoting this project if you find it useful.
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT 
+OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/bypass.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/bypass.go
@ -0,0 +1,152 @@
+// Copyright (c) 2015 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is not running on Google App Engine, compiled by GopherJS, and
+// "-tags safe" is not added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build !js,!appengine,!safe,!disableunsafe
+
+package spew
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = false
+
+	// ptrSize is the size of a pointer on the current arch.
+	ptrSize = unsafe.Sizeof((*byte)(nil))
+)
+
+var (
+	// offsetPtr, offsetScalar, and offsetFlag are the offsets for the
+	// internal reflect.Value fields.  These values are valid before golang
+	// commit ecccf07e7f9d which changed the format.  The are also valid
+	// after commit 82f48826c6c7 which changed the format again to mirror
+	// the original format.  Code in the init function updates these offsets
+	// as necessary.
+	offsetPtr    = uintptr(ptrSize)
+	offsetScalar = uintptr(0)
+	offsetFlag   = uintptr(ptrSize * 2)
+
+	// flagKindWidth and flagKindShift indicate various bits that the
+	// reflect package uses internally to track kind information.
+	//
+	// flagRO indicates whether or not the value field of a reflect.Value is
+	// read-only.
+	//
+	// flagIndir indicates whether the value field of a reflect.Value is
+	// the actual data or a pointer to the data.
+	//
+	// These values are valid before golang commit 90a7c3c86944 which
+	// changed their positions.  Code in the init function updates these
+	// flags as necessary.
+	flagKindWidth = uintptr(5)
+	flagKindShift = uintptr(flagKindWidth - 1)
+	flagRO        = uintptr(1 << 0)
+	flagIndir     = uintptr(1 << 1)
+)
+
+func init() {
+	// Older versions of reflect.Value stored small integers directly in the
+	// ptr field (which is named val in the older versions).  Versions
+	// between commits ecccf07e7f9d and 82f48826c6c7 added a new field named
+	// scalar for this purpose which unfortunately came before the flag
+	// field, so the offset of the flag field is different for those
+	// versions.
+	//
+	// This code constructs a new reflect.Value from a known small integer
+	// and checks if the size of the reflect.Value struct indicates it has
+	// the scalar field. When it does, the offsets are updated accordingly.
+	vv := reflect.ValueOf(0xf00)
+	if unsafe.Sizeof(vv) == (ptrSize * 4) {
+		offsetScalar = ptrSize * 2
+		offsetFlag = ptrSize * 3
+	}
+
+	// Commit 90a7c3c86944 changed the flag positions such that the low
+	// order bits are the kind.  This code extracts the kind from the flags
+	// field and ensures it's the correct type.  When it's not, the flag
+	// order has been changed to the newer format, so the flags are updated
+	// accordingly.
+	upf := unsafe.Pointer(uintptr(unsafe.Pointer(&vv)) + offsetFlag)
+	upfv := *(*uintptr)(upf)
+	flagKindMask := uintptr((1<<flagKindWidth - 1) << flagKindShift)
+	if (upfv&flagKindMask)>>flagKindShift != uintptr(reflect.Int) {
+		flagKindShift = 0
+		flagRO = 1 << 5
+		flagIndir = 1 << 6
+
+		// Commit adf9b30e5594 modified the flags to separate the
+		// flagRO flag into two bits which specifies whether or not the
+		// field is embedded.  This causes flagIndir to move over a bit
+		// and means that flagRO is the combination of either of the
+		// original flagRO bit and the new bit.
+		//
+		// This code detects the change by extracting what used to be
+		// the indirect bit to ensure it's set.  When it's not, the flag
+		// order has been changed to the newer format, so the flags are
+		// updated accordingly.
+		if upfv&flagIndir == 0 {
+			flagRO = 3 << 5
+			flagIndir = 1 << 7
+		}
+	}
+}
+
+// unsafeReflectValue converts the passed reflect.Value into a one that bypasses
+// the typical safety restrictions preventing access to unaddressable and
+// unexported data.  It works by digging the raw pointer to the underlying
+// value out of the protected value and generating a new unprotected (unsafe)
+// reflect.Value to it.
+//
+// This allows us to check for implementations of the Stringer and error
+// interfaces to be used for pretty printing ordinarily unaddressable and
+// inaccessible values such as unexported struct fields.
+func unsafeReflectValue(v reflect.Value) (rv reflect.Value) {
+	indirects := 1
+	vt := v.Type()
+	upv := unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetPtr)
+	rvf := *(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&v)) + offsetFlag))
+	if rvf&flagIndir != 0 {
+		vt = reflect.PtrTo(v.Type())
+		indirects++
+	} else if offsetScalar != 0 {
+		// The value is in the scalar field when it's not one of the
+		// reference types.
+		switch vt.Kind() {
+		case reflect.Uintptr:
+		case reflect.Chan:
+		case reflect.Func:
+		case reflect.Map:
+		case reflect.Ptr:
+		case reflect.UnsafePointer:
+		default:
+			upv = unsafe.Pointer(uintptr(unsafe.Pointer(&v)) +
+				offsetScalar)
+		}
+	}
+
+	pv := reflect.NewAt(vt, upv)
+	rv = pv
+	for i := 0; i < indirects; i++ {
+		rv = rv.Elem()
+	}
+	return rv
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go
@ -0,0 +1,38 @@
+// Copyright (c) 2015 Dave Collins <dave@davec.name>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+// NOTE: Due to the following build constraints, this file will only be compiled
+// when the code is running on Google App Engine, compiled by GopherJS, or
+// "-tags safe" is added to the go build command line.  The "disableunsafe"
+// tag is deprecated and thus should not be used.
+// +build js appengine safe disableunsafe
+
+package spew
+
+import "reflect"
+
+const (
+	// UnsafeDisabled is a build-time constant which specifies whether or
+	// not access to the unsafe package is available.
+	UnsafeDisabled = true
+)
+
+// unsafeReflectValue typically converts the passed reflect.Value into a one
+// that bypasses the typical safety restrictions preventing access to
+// unaddressable and unexported data.  However, doing this relies on access to
+// the unsafe package.  This is a stub version which simply returns the passed
+// reflect.Value when the unsafe package is not available.
+func unsafeReflectValue(v reflect.Value) reflect.Value {
+	return v
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/common.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/common.go
@ -0,0 +1,341 @@
+/*
+ * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+)
+
+// Some constants in the form of bytes to avoid string overhead.  This mirrors
+// the technique used in the fmt package.
+var (
+	panicBytes            = []byte("(PANIC=")
+	plusBytes             = []byte("+")
+	iBytes                = []byte("i")
+	trueBytes             = []byte("true")
+	falseBytes            = []byte("false")
+	interfaceBytes        = []byte("(interface {})")
+	commaNewlineBytes     = []byte(",\n")
+	newlineBytes          = []byte("\n")
+	openBraceBytes        = []byte("{")
+	openBraceNewlineBytes = []byte("{\n")
+	closeBraceBytes       = []byte("}")
+	asteriskBytes         = []byte("*")
+	colonBytes            = []byte(":")
+	colonSpaceBytes       = []byte(": ")
+	openParenBytes        = []byte("(")
+	closeParenBytes       = []byte(")")
+	spaceBytes            = []byte(" ")
+	pointerChainBytes     = []byte("->")
+	nilAngleBytes         = []byte("<nil>")
+	maxNewlineBytes       = []byte("<max depth reached>\n")
+	maxShortBytes         = []byte("<max>")
+	circularBytes         = []byte("<already shown>")
+	circularShortBytes    = []byte("<shown>")
+	invalidAngleBytes     = []byte("<invalid>")
+	openBracketBytes      = []byte("[")
+	closeBracketBytes     = []byte("]")
+	percentBytes          = []byte("%")
+	precisionBytes        = []byte(".")
+	openAngleBytes        = []byte("<")
+	closeAngleBytes       = []byte(">")
+	openMapBytes          = []byte("map[")
+	closeMapBytes         = []byte("]")
+	lenEqualsBytes        = []byte("len=")
+	capEqualsBytes        = []byte("cap=")
+)
+
+// hexDigits is used to map a decimal value to a hex digit.
+var hexDigits = "0123456789abcdef"
+
+// catchPanic handles any panics that might occur during the handleMethods
+// calls.
+func catchPanic(w io.Writer, v reflect.Value) {
+	if err := recover(); err != nil {
+		w.Write(panicBytes)
+		fmt.Fprintf(w, "%v", err)
+		w.Write(closeParenBytes)
+	}
+}
+
+// handleMethods attempts to call the Error and String methods on the underlying
+// type the passed reflect.Value represents and outputes the result to Writer w.
+//
+// It handles panics in any called methods by catching and displaying the error
+// as the formatted value.
+func handleMethods(cs *ConfigState, w io.Writer, v reflect.Value) (handled bool) {
+	// We need an interface to check if the type implements the error or
+	// Stringer interface.  However, the reflect package won't give us an
+	// interface on certain things like unexported struct fields in order
+	// to enforce visibility rules.  We use unsafe, when it's available,
+	// to bypass these restrictions since this package does not mutate the
+	// values.
+	if !v.CanInterface() {
+		if UnsafeDisabled {
+			return false
+		}
+
+		v = unsafeReflectValue(v)
+	}
+
+	// Choose whether or not to do error and Stringer interface lookups against
+	// the base type or a pointer to the base type depending on settings.
+	// Technically calling one of these methods with a pointer receiver can
+	// mutate the value, however, types which choose to satisify an error or
+	// Stringer interface with a pointer receiver should not be mutating their
+	// state inside these interface methods.
+	if !cs.DisablePointerMethods && !UnsafeDisabled && !v.CanAddr() {
+		v = unsafeReflectValue(v)
+	}
+	if v.CanAddr() {
+		v = v.Addr()
+	}
+
+	// Is it an error or Stringer?
+	switch iface := v.Interface().(type) {
+	case error:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.Error()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+
+		w.Write([]byte(iface.Error()))
+		return true
+
+	case fmt.Stringer:
+		defer catchPanic(w, v)
+		if cs.ContinueOnMethod {
+			w.Write(openParenBytes)
+			w.Write([]byte(iface.String()))
+			w.Write(closeParenBytes)
+			w.Write(spaceBytes)
+			return false
+		}
+		w.Write([]byte(iface.String()))
+		return true
+	}
+	return false
+}
+
+// printBool outputs a boolean value as true or false to Writer w.
+func printBool(w io.Writer, val bool) {
+	if val {
+		w.Write(trueBytes)
+	} else {
+		w.Write(falseBytes)
+	}
+}
+
+// printInt outputs a signed integer value to Writer w.
+func printInt(w io.Writer, val int64, base int) {
+	w.Write([]byte(strconv.FormatInt(val, base)))
+}
+
+// printUint outputs an unsigned integer value to Writer w.
+func printUint(w io.Writer, val uint64, base int) {
+	w.Write([]byte(strconv.FormatUint(val, base)))
+}
+
+// printFloat outputs a floating point value using the specified precision,
+// which is expected to be 32 or 64bit, to Writer w.
+func printFloat(w io.Writer, val float64, precision int) {
+	w.Write([]byte(strconv.FormatFloat(val, 'g', -1, precision)))
+}
+
+// printComplex outputs a complex value using the specified float precision
+// for the real and imaginary parts to Writer w.
+func printComplex(w io.Writer, c complex128, floatPrecision int) {
+	r := real(c)
+	w.Write(openParenBytes)
+	w.Write([]byte(strconv.FormatFloat(r, 'g', -1, floatPrecision)))
+	i := imag(c)
+	if i >= 0 {
+		w.Write(plusBytes)
+	}
+	w.Write([]byte(strconv.FormatFloat(i, 'g', -1, floatPrecision)))
+	w.Write(iBytes)
+	w.Write(closeParenBytes)
+}
+
+// printHexPtr outputs a uintptr formatted as hexidecimal with a leading '0x'
+// prefix to Writer w.
+func printHexPtr(w io.Writer, p uintptr) {
+	// Null pointer.
+	num := uint64(p)
+	if num == 0 {
+		w.Write(nilAngleBytes)
+		return
+	}
+
+	// Max uint64 is 16 bytes in hex + 2 bytes for '0x' prefix
+	buf := make([]byte, 18)
+
+	// It's simpler to construct the hex string right to left.
+	base := uint64(16)
+	i := len(buf) - 1
+	for num >= base {
+		buf[i] = hexDigits[num%base]
+		num /= base
+		i--
+	}
+	buf[i] = hexDigits[num]
+
+	// Add '0x' prefix.
+	i--
+	buf[i] = 'x'
+	i--
+	buf[i] = '0'
+
+	// Strip unused leading bytes.
+	buf = buf[i:]
+	w.Write(buf)
+}
+
+// valuesSorter implements sort.Interface to allow a slice of reflect.Value
+// elements to be sorted.
+type valuesSorter struct {
+	values  []reflect.Value
+	strings []string // either nil or same len and values
+	cs      *ConfigState
+}
+
+// newValuesSorter initializes a valuesSorter instance, which holds a set of
+// surrogate keys on which the data should be sorted.  It uses flags in
+// ConfigState to decide if and how to populate those surrogate keys.
+func newValuesSorter(values []reflect.Value, cs *ConfigState) sort.Interface {
+	vs := &valuesSorter{values: values, cs: cs}
+	if canSortSimply(vs.values[0].Kind()) {
+		return vs
+	}
+	if !cs.DisableMethods {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			b := bytes.Buffer{}
+			if !handleMethods(cs, &b, vs.values[i]) {
+				vs.strings = nil
+				break
+			}
+			vs.strings[i] = b.String()
+		}
+	}
+	if vs.strings == nil && cs.SpewKeys {
+		vs.strings = make([]string, len(values))
+		for i := range vs.values {
+			vs.strings[i] = Sprintf("%#v", vs.values[i].Interface())
+		}
+	}
+	return vs
+}
+
+// canSortSimply tests whether a reflect.Kind is a primitive that can be sorted
+// directly, or whether it should be considered for sorting by surrogate keys
+// (if the ConfigState allows it).
+func canSortSimply(kind reflect.Kind) bool {
+	// This switch parallels valueSortLess, except for the default case.
+	switch kind {
+	case reflect.Bool:
+		return true
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return true
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return true
+	case reflect.Float32, reflect.Float64:
+		return true
+	case reflect.String:
+		return true
+	case reflect.Uintptr:
+		return true
+	case reflect.Array:
+		return true
+	}
+	return false
+}
+
+// Len returns the number of values in the slice.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Len() int {
+	return len(s.values)
+}
+
+// Swap swaps the values at the passed indices.  It is part of the
+// sort.Interface implementation.
+func (s *valuesSorter) Swap(i, j int) {
+	s.values[i], s.values[j] = s.values[j], s.values[i]
+	if s.strings != nil {
+		s.strings[i], s.strings[j] = s.strings[j], s.strings[i]
+	}
+}
+
+// valueSortLess returns whether the first value should sort before the second
+// value.  It is used by valueSorter.Less as part of the sort.Interface
+// implementation.
+func valueSortLess(a, b reflect.Value) bool {
+	switch a.Kind() {
+	case reflect.Bool:
+		return !a.Bool() && b.Bool()
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		return a.Int() < b.Int()
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		return a.Uint() < b.Uint()
+	case reflect.Float32, reflect.Float64:
+		return a.Float() < b.Float()
+	case reflect.String:
+		return a.String() < b.String()
+	case reflect.Uintptr:
+		return a.Uint() < b.Uint()
+	case reflect.Array:
+		// Compare the contents of both arrays.
+		l := a.Len()
+		for i := 0; i < l; i++ {
+			av := a.Index(i)
+			bv := b.Index(i)
+			if av.Interface() == bv.Interface() {
+				continue
+			}
+			return valueSortLess(av, bv)
+		}
+	}
+	return a.String() < b.String()
+}
+
+// Less returns whether the value at index i should sort before the
+// value at index j.  It is part of the sort.Interface implementation.
+func (s *valuesSorter) Less(i, j int) bool {
+	if s.strings == nil {
+		return valueSortLess(s.values[i], s.values[j])
+	}
+	return s.strings[i] < s.strings[j]
+}
+
+// sortValues is a sort function that handles both native types and any type that
+// can be converted to error or Stringer.  Other inputs are sorted according to
+// their Value.String() value to ensure display stability.
+func sortValues(values []reflect.Value, cs *ConfigState) {
+	if len(values) == 0 {
+		return
+	}
+	sort.Sort(newValuesSorter(values, cs))
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/config.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/config.go
@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// ConfigState houses the configuration options used by spew to format and
+// display values.  There is a global instance, Config, that is used to control
+// all top-level Formatter and Dump functionality.  Each ConfigState instance
+// provides methods equivalent to the top-level functions.
+//
+// The zero value for ConfigState provides no indentation.  You would typically
+// want to set it to a space or a tab.
+//
+// Alternatively, you can use NewDefaultConfig to get a ConfigState instance
+// with default settings.  See the documentation of NewDefaultConfig for default
+// values.
+type ConfigState struct {
+	// Indent specifies the string to use for each indentation level.  The
+	// global config instance that all top-level functions use set this to a
+	// single space by default.  If you would like more indentation, you might
+	// set this to a tab with "\t" or perhaps two spaces with "  ".
+	Indent string
+
+	// MaxDepth controls the maximum number of levels to descend into nested
+	// data structures.  The default, 0, means there is no limit.
+	//
+	// NOTE: Circular data structures are properly detected, so it is not
+	// necessary to set this value unless you specifically want to limit deeply
+	// nested data structures.
+	MaxDepth int
+
+	// DisableMethods specifies whether or not error and Stringer interfaces are
+	// invoked for types that implement them.
+	DisableMethods bool
+
+	// DisablePointerMethods specifies whether or not to check for and invoke
+	// error and Stringer interfaces on types which only accept a pointer
+	// receiver when the current type is not a pointer.
+	//
+	// NOTE: This might be an unsafe action since calling one of these methods
+	// with a pointer receiver could technically mutate the value, however,
+	// in practice, types which choose to satisify an error or Stringer
+	// interface with a pointer receiver should not be mutating their state
+	// inside these interface methods.  As a result, this option relies on
+	// access to the unsafe package, so it will not have any effect when
+	// running in environments without access to the unsafe package such as
+	// Google App Engine or with the "safe" build tag specified.
+	DisablePointerMethods bool
+
+	// DisablePointerAddresses specifies whether to disable the printing of
+	// pointer addresses. This is useful when diffing data structures in tests.
+	DisablePointerAddresses bool
+
+	// DisableCapacities specifies whether to disable the printing of capacities
+	// for arrays, slices, maps and channels. This is useful when diffing
+	// data structures in tests.
+	DisableCapacities bool
+
+	// ContinueOnMethod specifies whether or not recursion should continue once
+	// a custom error or Stringer interface is invoked.  The default, false,
+	// means it will print the results of invoking the custom error or Stringer
+	// interface and return immediately instead of continuing to recurse into
+	// the internals of the data type.
+	//
+	// NOTE: This flag does not have any effect if method invocation is disabled
+	// via the DisableMethods or DisablePointerMethods options.
+	ContinueOnMethod bool
+
+	// SortKeys specifies map keys should be sorted before being printed. Use
+	// this to have a more deterministic, diffable output.  Note that only
+	// native types (bool, int, uint, floats, uintptr and string) and types
+	// that support the error or Stringer interfaces (if methods are
+	// enabled) are supported, with other types sorted according to the
+	// reflect.Value.String() output which guarantees display stability.
+	SortKeys bool
+
+	// SpewKeys specifies that, as a last resort attempt, map keys should
+	// be spewed to strings and sorted by those strings.  This is only
+	// considered if SortKeys is true.
+	SpewKeys bool
+}
+
+// Config is the active configuration of the top-level functions.
+// The configuration can be changed by modifying the contents of spew.Config.
+var Config = ConfigState{Indent: " "}
+
+// Errorf is a wrapper for fmt.Errorf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the formatted string as a value that satisfies error.  See NewFormatter
+// for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Errorf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Errorf(format string, a ...interface{}) (err error) {
+	return fmt.Errorf(format, c.convertArgs(a)...)
+}
+
+// Fprint is a wrapper for fmt.Fprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprint(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprint(w, c.convertArgs(a)...)
+}
+
+// Fprintf is a wrapper for fmt.Fprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintf(w, format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
+	return fmt.Fprintf(w, format, c.convertArgs(a)...)
+}
+
+// Fprintln is a wrapper for fmt.Fprintln that treats each argument as if it
+// passed with a Formatter interface returned by c.NewFormatter.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Fprintln(w, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
+	return fmt.Fprintln(w, c.convertArgs(a)...)
+}
+
+// Print is a wrapper for fmt.Print that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Print(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Print(a ...interface{}) (n int, err error) {
+	return fmt.Print(c.convertArgs(a)...)
+}
+
+// Printf is a wrapper for fmt.Printf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Printf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Printf(format string, a ...interface{}) (n int, err error) {
+	return fmt.Printf(format, c.convertArgs(a)...)
+}
+
+// Println is a wrapper for fmt.Println that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the number of bytes written and any write error encountered.  See
+// NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Println(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Println(a ...interface{}) (n int, err error) {
+	return fmt.Println(c.convertArgs(a)...)
+}
+
+// Sprint is a wrapper for fmt.Sprint that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprint(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprint(a ...interface{}) string {
+	return fmt.Sprint(c.convertArgs(a)...)
+}
+
+// Sprintf is a wrapper for fmt.Sprintf that treats each argument as if it were
+// passed with a Formatter interface returned by c.NewFormatter.  It returns
+// the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintf(format, c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintf(format string, a ...interface{}) string {
+	return fmt.Sprintf(format, c.convertArgs(a)...)
+}
+
+// Sprintln is a wrapper for fmt.Sprintln that treats each argument as if it
+// were passed with a Formatter interface returned by c.NewFormatter.  It
+// returns the resulting string.  See NewFormatter for formatting details.
+//
+// This function is shorthand for the following syntax:
+//
+//	fmt.Sprintln(c.NewFormatter(a), c.NewFormatter(b))
+func (c *ConfigState) Sprintln(a ...interface{}) string {
+	return fmt.Sprintln(c.convertArgs(a)...)
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), and %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+c.Printf, c.Println, or c.Printf.
+*/
+func (c *ConfigState) NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(c, v)
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func (c *ConfigState) Fdump(w io.Writer, a ...interface{}) {
+	fdump(c, w, a...)
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by modifying the public members
+of c.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func (c *ConfigState) Dump(a ...interface{}) {
+	fdump(c, os.Stdout, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func (c *ConfigState) Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(c, &buf, a...)
+	return buf.String()
+}
+
+// convertArgs accepts a slice of arguments and returns a slice of the same
+// length with each argument converted to a spew Formatter interface using
+// the ConfigState associated with s.
+func (c *ConfigState) convertArgs(args []interface{}) (formatters []interface{}) {
+	formatters = make([]interface{}, len(args))
+	for index, arg := range args {
+		formatters[index] = newFormatter(c, arg)
+	}
+	return formatters
+}
+
+// NewDefaultConfig returns a ConfigState with the following default settings.
+//
+// 	Indent: " "
+// 	MaxDepth: 0
+// 	DisableMethods: false
+// 	DisablePointerMethods: false
+// 	ContinueOnMethod: false
+// 	SortKeys: false
+func NewDefaultConfig() *ConfigState {
+	return &ConfigState{Indent: " "}
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/doc.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/doc.go
@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+Package spew implements a deep pretty printer for Go data structures to aid in
+debugging.
+
+A quick overview of the additional features spew provides over the built-in
+printing facilities for Go data types are as follows:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output (only when using
+	  Dump style)
+
+There are two different approaches spew allows for dumping Go data structures:
+
+	* Dump style which prints with newlines, customizable indentation,
+	  and additional debug information such as types and all pointer addresses
+	  used to indirect to the final value
+	* A custom Formatter interface that integrates cleanly with the standard fmt
+	  package and replaces %v, %+v, %#v, and %#+v to provide inline printing
+	  similar to the default %v while providing the additional functionality
+	  outlined above and passing unsupported format verbs such as %x and %q
+	  along to fmt
+
+Quick Start
+
+This section demonstrates how to quickly get started with spew.  See the
+sections below for further details on formatting and configuration options.
+
+To dump a variable with full newlines, indentation, type, and pointer
+information use Dump, Fdump, or Sdump:
+	spew.Dump(myVar1, myVar2, ...)
+	spew.Fdump(someWriter, myVar1, myVar2, ...)
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Alternatively, if you would prefer to use format strings with a compacted inline
+printing style, use the convenience wrappers Printf, Fprintf, etc with
+%v (most compact), %+v (adds pointer addresses), %#v (adds types), or
+%#+v (adds types and pointer addresses):
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Fprintf(someWriter, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(someWriter, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+Configuration Options
+
+Configuration of spew is handled by fields in the ConfigState type.  For
+convenience, all of the top-level functions use a global state available
+via the spew.Config global.
+
+It is also possible to create a ConfigState instance that provides methods
+equivalent to the top-level functions.  This allows concurrent configuration
+options.  See the ConfigState documentation for more details.
+
+The following configuration options are available:
+	* Indent
+		String to use for each indentation level for Dump functions.
+		It is a single space by default.  A popular alternative is "\t".
+
+	* MaxDepth
+		Maximum number of levels to descend into nested data structures.
+		There is no limit by default.
+
+	* DisableMethods
+		Disables invocation of error and Stringer interface methods.
+		Method invocation is enabled by default.
+
+	* DisablePointerMethods
+		Disables invocation of error and Stringer interface methods on types
+		which only accept pointer receivers from non-pointer variables.
+		Pointer method invocation is enabled by default.
+
+	* ContinueOnMethod
+		Enables recursion into types after invoking error and Stringer interface
+		methods. Recursion after method invocation is disabled by default.
+
+	* SortKeys
+		Specifies map keys should be sorted before being printed. Use
+		this to have a more deterministic, diffable output.  Note that
+		only native types (bool, int, uint, floats, uintptr and string)
+		and types which implement error or Stringer interfaces are
+		supported with other types sorted according to the
+		reflect.Value.String() output which guarantees display
+		stability.  Natural map order is used by default.
+
+	* SpewKeys
+		Specifies that, as a last resort attempt, map keys should be
+		spewed to strings and sorted by those strings.  This is only
+		considered if SortKeys is true.
+
+Dump Usage
+
+Simply call spew.Dump with a list of variables you want to dump:
+
+	spew.Dump(myVar1, myVar2, ...)
+
+You may also call spew.Fdump if you would prefer to output to an arbitrary
+io.Writer.  For example, to dump to standard error:
+
+	spew.Fdump(os.Stderr, myVar1, myVar2, ...)
+
+A third option is to call spew.Sdump to get the formatted output as a string:
+
+	str := spew.Sdump(myVar1, myVar2, ...)
+
+Sample Dump Output
+
+See the Dump example for details on the setup of the types and variables being
+shown here.
+
+	(main.Foo) {
+	 unexportedField: (*main.Bar)(0xf84002e210)({
+	  flag: (main.Flag) flagTwo,
+	  data: (uintptr) <nil>
+	 }),
+	 ExportedField: (map[interface {}]interface {}) (len=1) {
+	  (string) (len=3) "one": (bool) true
+	 }
+	}
+
+Byte (and uint8) arrays and slices are displayed uniquely like the hexdump -C
+command as shown.
+	([]uint8) (len=32 cap=32) {
+	 00000000  11 12 13 14 15 16 17 18  19 1a 1b 1c 1d 1e 1f 20  |............... |
+	 00000010  21 22 23 24 25 26 27 28  29 2a 2b 2c 2d 2e 2f 30  |!"#$%&'()*+,-./0|
+	 00000020  31 32                                             |12|
+	}
+
+Custom Formatter
+
+Spew provides a custom formatter that implements the fmt.Formatter interface
+so that it integrates cleanly with standard fmt package printing functions. The
+formatter is useful for inline printing of smaller data types similar to the
+standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Custom Formatter Usage
+
+The simplest way to make use of the spew custom formatter is to call one of the
+convenience functions such as spew.Printf, spew.Println, or spew.Printf.  The
+functions have syntax you are most likely already familiar with:
+
+	spew.Printf("myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Printf("myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+	spew.Println(myVar, myVar2)
+	spew.Fprintf(os.Stderr, "myVar1: %v -- myVar2: %+v", myVar1, myVar2)
+	spew.Fprintf(os.Stderr, "myVar3: %#v -- myVar4: %#+v", myVar3, myVar4)
+
+See the Index for the full list convenience functions.
+
+Sample Formatter Output
+
+Double pointer to a uint8:
+	  %v: <**>5
+	 %+v: <**>(0xf8400420d0->0xf8400420c8)5
+	 %#v: (**uint8)5
+	%#+v: (**uint8)(0xf8400420d0->0xf8400420c8)5
+
+Pointer to circular struct with a uint8 field and a pointer to itself:
+	  %v: <*>{1 <*><shown>}
+	 %+v: <*>(0xf84003e260){ui8:1 c:<*>(0xf84003e260)<shown>}
+	 %#v: (*main.circular){ui8:(uint8)1 c:(*main.circular)<shown>}
+	%#+v: (*main.circular)(0xf84003e260){ui8:(uint8)1 c:(*main.circular)(0xf84003e260)<shown>}
+
+See the Printf example for details on the setup of variables being shown
+here.
+
+Errors
+
+Since it is possible for custom Stringer/error interfaces to panic, spew
+detects them and handles them internally by printing the panic information
+inline with the output.  Since spew is intended to provide deep pretty printing
+capabilities on structures, it intentionally does not return any errors.
+*/
+package spew
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/dump.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/dump.go
@ -0,0 +1,509 @@
+/*
+ * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var (
+	// uint8Type is a reflect.Type representing a uint8.  It is used to
+	// convert cgo types to uint8 slices for hexdumping.
+	uint8Type = reflect.TypeOf(uint8(0))
+
+	// cCharRE is a regular expression that matches a cgo char.
+	// It is used to detect character arrays to hexdump them.
+	cCharRE = regexp.MustCompile("^.*\\._Ctype_char$")
+
+	// cUnsignedCharRE is a regular expression that matches a cgo unsigned
+	// char.  It is used to detect unsigned character arrays to hexdump
+	// them.
+	cUnsignedCharRE = regexp.MustCompile("^.*\\._Ctype_unsignedchar$")
+
+	// cUint8tCharRE is a regular expression that matches a cgo uint8_t.
+	// It is used to detect uint8_t arrays to hexdump them.
+	cUint8tCharRE = regexp.MustCompile("^.*\\._Ctype_uint8_t$")
+)
+
+// dumpState contains information about the state of a dump operation.
+type dumpState struct {
+	w                io.Writer
+	depth            int
+	pointers         map[uintptr]int
+	ignoreNextType   bool
+	ignoreNextIndent bool
+	cs               *ConfigState
+}
+
+// indent performs indentation according to the depth level and cs.Indent
+// option.
+func (d *dumpState) indent() {
+	if d.ignoreNextIndent {
+		d.ignoreNextIndent = false
+		return
+	}
+	d.w.Write(bytes.Repeat([]byte(d.cs.Indent), d.depth))
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (d *dumpState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface && !v.IsNil() {
+		v = v.Elem()
+	}
+	return v
+}
+
+// dumpPtr handles formatting of pointers by indirecting them as necessary.
+func (d *dumpState) dumpPtr(v reflect.Value) {
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range d.pointers {
+		if depth >= d.depth {
+			delete(d.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by dereferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := d.pointers[addr]; ok && pd < d.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		d.pointers[addr] = d.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type information.
+	d.w.Write(openParenBytes)
+	d.w.Write(bytes.Repeat(asteriskBytes, indirects))
+	d.w.Write([]byte(ve.Type().String()))
+	d.w.Write(closeParenBytes)
+
+	// Display pointer information.
+	if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 {
+		d.w.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				d.w.Write(pointerChainBytes)
+			}
+			printHexPtr(d.w, addr)
+		}
+		d.w.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	d.w.Write(openParenBytes)
+	switch {
+	case nilFound == true:
+		d.w.Write(nilAngleBytes)
+
+	case cycleFound == true:
+		d.w.Write(circularBytes)
+
+	default:
+		d.ignoreNextType = true
+		d.dump(ve)
+	}
+	d.w.Write(closeParenBytes)
+}
+
+// dumpSlice handles formatting of arrays and slices.  Byte (uint8 under
+// reflection) arrays and slices are dumped in hexdump -C fashion.
+func (d *dumpState) dumpSlice(v reflect.Value) {
+	// Determine whether this type should be hex dumped or not.  Also,
+	// for types which should be hexdumped, try to use the underlying data
+	// first, then fall back to trying to convert them to a uint8 slice.
+	var buf []uint8
+	doConvert := false
+	doHexDump := false
+	numEntries := v.Len()
+	if numEntries > 0 {
+		vt := v.Index(0).Type()
+		vts := vt.String()
+		switch {
+		// C types that need to be converted.
+		case cCharRE.MatchString(vts):
+			fallthrough
+		case cUnsignedCharRE.MatchString(vts):
+			fallthrough
+		case cUint8tCharRE.MatchString(vts):
+			doConvert = true
+
+		// Try to use existing uint8 slices and fall back to converting
+		// and copying if that fails.
+		case vt.Kind() == reflect.Uint8:
+			// We need an addressable interface to convert the type
+			// to a byte slice.  However, the reflect package won't
+			// give us an interface on certain things like
+			// unexported struct fields in order to enforce
+			// visibility rules.  We use unsafe, when available, to
+			// bypass these restrictions since this package does not
+			// mutate the values.
+			vs := v
+			if !vs.CanInterface() || !vs.CanAddr() {
+				vs = unsafeReflectValue(vs)
+			}
+			if !UnsafeDisabled {
+				vs = vs.Slice(0, numEntries)
+
+				// Use the existing uint8 slice if it can be
+				// type asserted.
+				iface := vs.Interface()
+				if slice, ok := iface.([]uint8); ok {
+					buf = slice
+					doHexDump = true
+					break
+				}
+			}
+
+			// The underlying data needs to be converted if it can't
+			// be type asserted to a uint8 slice.
+			doConvert = true
+		}
+
+		// Copy and convert the underlying type if needed.
+		if doConvert && vt.ConvertibleTo(uint8Type) {
+			// Convert and copy each element into a uint8 byte
+			// slice.
+			buf = make([]uint8, numEntries)
+			for i := 0; i < numEntries; i++ {
+				vv := v.Index(i)
+				buf[i] = uint8(vv.Convert(uint8Type).Uint())
+			}
+			doHexDump = true
+		}
+	}
+
+	// Hexdump the entire slice as needed.
+	if doHexDump {
+		indent := strings.Repeat(d.cs.Indent, d.depth)
+		str := indent + hex.Dump(buf)
+		str = strings.Replace(str, "\n", "\n"+indent, -1)
+		str = strings.TrimRight(str, d.cs.Indent)
+		d.w.Write([]byte(str))
+		return
+	}
+
+	// Recursively call dump for each item.
+	for i := 0; i < numEntries; i++ {
+		d.dump(d.unpackValue(v.Index(i)))
+		if i < (numEntries - 1) {
+			d.w.Write(commaNewlineBytes)
+		} else {
+			d.w.Write(newlineBytes)
+		}
+	}
+}
+
+// dump is the main workhorse for dumping a value.  It uses the passed reflect
+// value to figure out what kind of object we are dealing with and formats it
+// appropriately.  It is a recursive function, however circular data structures
+// are detected and handled properly.
+func (d *dumpState) dump(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		d.w.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		d.indent()
+		d.dumpPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !d.ignoreNextType {
+		d.indent()
+		d.w.Write(openParenBytes)
+		d.w.Write([]byte(v.Type().String()))
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+	d.ignoreNextType = false
+
+	// Display length and capacity if the built-in len and cap functions
+	// work with the value's kind and the len/cap itself is non-zero.
+	valueLen, valueCap := 0, 0
+	switch v.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Chan:
+		valueLen, valueCap = v.Len(), v.Cap()
+	case reflect.Map, reflect.String:
+		valueLen = v.Len()
+	}
+	if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 {
+		d.w.Write(openParenBytes)
+		if valueLen != 0 {
+			d.w.Write(lenEqualsBytes)
+			printInt(d.w, int64(valueLen), 10)
+		}
+		if !d.cs.DisableCapacities && valueCap != 0 {
+			if valueLen != 0 {
+				d.w.Write(spaceBytes)
+			}
+			d.w.Write(capEqualsBytes)
+			printInt(d.w, int64(valueCap), 10)
+		}
+		d.w.Write(closeParenBytes)
+		d.w.Write(spaceBytes)
+	}
+
+	// Call Stringer/error interfaces if they exist and the handle methods flag
+	// is enabled
+	if !d.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(d.cs, d.w, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(d.w, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(d.w, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(d.w, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(d.w, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(d.w, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(d.w, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(d.w, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			d.dumpSlice(v)
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.String:
+		d.w.Write([]byte(strconv.Quote(v.String())))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			d.w.Write(nilAngleBytes)
+			break
+		}
+
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			numEntries := v.Len()
+			keys := v.MapKeys()
+			if d.cs.SortKeys {
+				sortValues(keys, d.cs)
+			}
+			for i, key := range keys {
+				d.dump(d.unpackValue(key))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.MapIndex(key)))
+				if i < (numEntries - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Struct:
+		d.w.Write(openBraceNewlineBytes)
+		d.depth++
+		if (d.cs.MaxDepth != 0) && (d.depth > d.cs.MaxDepth) {
+			d.indent()
+			d.w.Write(maxNewlineBytes)
+		} else {
+			vt := v.Type()
+			numFields := v.NumField()
+			for i := 0; i < numFields; i++ {
+				d.indent()
+				vtf := vt.Field(i)
+				d.w.Write([]byte(vtf.Name))
+				d.w.Write(colonSpaceBytes)
+				d.ignoreNextIndent = true
+				d.dump(d.unpackValue(v.Field(i)))
+				if i < (numFields - 1) {
+					d.w.Write(commaNewlineBytes)
+				} else {
+					d.w.Write(newlineBytes)
+				}
+			}
+		}
+		d.depth--
+		d.indent()
+		d.w.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(d.w, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(d.w, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it in case any new
+	// types are added.
+	default:
+		if v.CanInterface() {
+			fmt.Fprintf(d.w, "%v", v.Interface())
+		} else {
+			fmt.Fprintf(d.w, "%v", v.String())
+		}
+	}
+}
+
+// fdump is a helper function to consolidate the logic from the various public
+// methods which take varying writers and config states.
+func fdump(cs *ConfigState, w io.Writer, a ...interface{}) {
+	for _, arg := range a {
+		if arg == nil {
+			w.Write(interfaceBytes)
+			w.Write(spaceBytes)
+			w.Write(nilAngleBytes)
+			w.Write(newlineBytes)
+			continue
+		}
+
+		d := dumpState{w: w, cs: cs}
+		d.pointers = make(map[uintptr]int)
+		d.dump(reflect.ValueOf(arg))
+		d.w.Write(newlineBytes)
+	}
+}
+
+// Fdump formats and displays the passed arguments to io.Writer w.  It formats
+// exactly the same as Dump.
+func Fdump(w io.Writer, a ...interface{}) {
+	fdump(&Config, w, a...)
+}
+
+// Sdump returns a string with the passed arguments formatted exactly the same
+// as Dump.
+func Sdump(a ...interface{}) string {
+	var buf bytes.Buffer
+	fdump(&Config, &buf, a...)
+	return buf.String()
+}
+
+/*
+Dump displays the passed parameters to standard out with newlines, customizable
+indentation, and additional debug information such as complete types and all
+pointer addresses used to indirect to the final value.  It provides the
+following features over the built-in printing facilities provided by the fmt
+package:
+
+	* Pointers are dereferenced and followed
+	* Circular data structures are detected and handled properly
+	* Custom Stringer/error interfaces are optionally invoked, including
+	  on unexported types
+	* Custom types which only implement the Stringer/error interfaces via
+	  a pointer receiver are optionally invoked when passing non-pointer
+	  variables
+	* Byte arrays and slices are dumped like the hexdump -C command which
+	  includes offsets, byte values in hex, and ASCII output
+
+The configuration options are controlled by an exported package global,
+spew.Config.  See ConfigState for options documentation.
+
+See Fdump if you would prefer dumping to an arbitrary io.Writer or Sdump to
+get the formatted result as a string.
+*/
+func Dump(a ...interface{}) {
+	fdump(&Config, os.Stdout, a...)
+}
--- a/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/format.go
+++ b/vendor/github.com/stretchr/testify/vendor/github.com/davecgh/go-spew/spew/format.go
@ -0,0 +1,419 @@
+/*
+ * Copyright (c) 2013 Dave Collins <dave@davec.name>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package spew
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// supportedFlags is a list of all the character flags supported by fmt package.
+const supportedFlags = "0-+# "
+
+// formatState implements the fmt.Formatter interface and contains information
+// about the state of a formatting operation.  The NewFormatter function can
+// be used to get a new Formatter which can be used directly as arguments
+// in standard fmt package printing calls.
+type formatState struct {
+	value          interface{}
+	fs             fmt.State
+	depth          int
+	pointers       map[uintptr]int
+	ignoreNextType bool
+	cs             *ConfigState
+}
+
+// buildDefaultFormat recreates the original format string without precision
+// and width information to pass in to fmt.Sprintf in the case of an
+// unrecognized type.  Unless new types are added to the language, this
+// function won't ever be called.
+func (f *formatState) buildDefaultFormat() (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	buf.WriteRune('v')
+
+	format = buf.String()
+	return format
+}
+
+// constructOrigFormat recreates the original format string including precision
+// and width information to pass along to the standard fmt package.  This allows
+// automatic deferral of all format strings this package doesn't support.
+func (f *formatState) constructOrigFormat(verb rune) (format string) {
+	buf := bytes.NewBuffer(percentBytes)
+
+	for _, flag := range supportedFlags {
+		if f.fs.Flag(int(flag)) {
+			buf.WriteRune(flag)
+		}
+	}
+
+	if width, ok := f.fs.Width(); ok {
+		buf.WriteString(strconv.Itoa(width))
+	}
+
+	if precision, ok := f.fs.Precision(); ok {
+		buf.Write(precisionBytes)
+		buf.WriteString(strconv.Itoa(precision))
+	}
+
+	buf.WriteRune(verb)
+
+	format = buf.String()
+	return format
+}
+
+// unpackValue returns values inside of non-nil interfaces when possible and
+// ensures that types for values which have been unpacked from an interface
+// are displayed when the show types flag is also set.
+// This is useful for data types like structs, arrays, slices, and maps which
+// can contain varying types packed inside an interface.
+func (f *formatState) unpackValue(v reflect.Value) reflect.Value {
+	if v.Kind() == reflect.Interface {
+		f.ignoreNextType = false
+		if !v.IsNil() {
+			v = v.Elem()
+		}
+	}
+	return v
+}
+
+// formatPtr handles formatting of pointers by indirecting them as necessary.
+func (f *formatState) formatPtr(v reflect.Value) {
+	// Display nil if top level pointer is nil.
+	showTypes := f.fs.Flag('#')
+	if v.IsNil() && (!showTypes || f.ignoreNextType) {
+		f.fs.Write(nilAngleBytes)
+		return
+	}
+
+	// Remove pointers at or below the current depth from map used to detect
+	// circular refs.
+	for k, depth := range f.pointers {
+		if depth >= f.depth {
+			delete(f.pointers, k)
+		}
+	}
+
+	// Keep list of all dereferenced pointers to possibly show later.
+	pointerChain := make([]uintptr, 0)
+
+	// Figure out how many levels of indirection there are by derferencing
+	// pointers and unpacking interfaces down the chain while detecting circular
+	// references.
+	nilFound := false
+	cycleFound := false
+	indirects := 0
+	ve := v
+	for ve.Kind() == reflect.Ptr {
+		if ve.IsNil() {
+			nilFound = true
+			break
+		}
+		indirects++
+		addr := ve.Pointer()
+		pointerChain = append(pointerChain, addr)
+		if pd, ok := f.pointers[addr]; ok && pd < f.depth {
+			cycleFound = true
+			indirects--
+			break
+		}
+		f.pointers[addr] = f.depth
+
+		ve = ve.Elem()
+		if ve.Kind() == reflect.Interface {
+			if ve.IsNil() {
+				nilFound = true
+				break
+			}
+			ve = ve.Elem()
+		}
+	}
+
+	// Display type or indirection level depending on flags.
+	if showTypes && !f.ignoreNextType {
+		f.fs.Write(openParenBytes)
+		f.fs.Write(bytes.Repeat(asteriskBytes, indirects))
+		f.fs.Write([]byte(ve.Type().String()))
+		f.fs.Write(closeParenBytes)
+	} else {
+		if nilFound || cycleFound {
+			indirects += strings.Count(ve.Type().String(), "*")
+		}
+		f.fs.Write(openAngleBytes)
+		f.fs.Write([]byte(strings.Repeat("*", indirects)))
+		f.fs.Write(closeAngleBytes)
+	}
+
+	// Display pointer information depending on flags.
+	if f.fs.Flag('+') && (len(pointerChain) > 0) {
+		f.fs.Write(openParenBytes)
+		for i, addr := range pointerChain {
+			if i > 0 {
+				f.fs.Write(pointerChainBytes)
+			}
+			printHexPtr(f.fs, addr)
+		}
+		f.fs.Write(closeParenBytes)
+	}
+
+	// Display dereferenced value.
+	switch {
+	case nilFound == true:
+		f.fs.Write(nilAngleBytes)
+
+	case cycleFound == true:
+		f.fs.Write(circularShortBytes)
+
+	default:
+		f.ignoreNextType = true
+		f.format(ve)
+	}
+}
+
+// format is the main workhorse for providing the Formatter interface.  It
+// uses the passed reflect value to figure out what kind of object we are
+// dealing with and formats it appropriately.  It is a recursive function,
+// however circular data structures are detected and handled properly.
+func (f *formatState) format(v reflect.Value) {
+	// Handle invalid reflect values immediately.
+	kind := v.Kind()
+	if kind == reflect.Invalid {
+		f.fs.Write(invalidAngleBytes)
+		return
+	}
+
+	// Handle pointers specially.
+	if kind == reflect.Ptr {
+		f.formatPtr(v)
+		return
+	}
+
+	// Print type information unless already handled elsewhere.
+	if !f.ignoreNextType && f.fs.Flag('#') {
+		f.fs.Write(openParenBytes)
+		f.fs.Write([]byte(v.Type().String()))
+		f.fs.Write(closeParenBytes)
+	}
+	f.ignoreNextType = false
+
+	// Call Stringer/error interfaces if they exist and the handle methods
+	// flag is enabled.
+	if !f.cs.DisableMethods {
+		if (kind != reflect.Invalid) && (kind != reflect.Interface) {
+			if handled := handleMethods(f.cs, f.fs, v); handled {
+				return
+			}
+		}
+	}
+
+	switch kind {
+	case reflect.Invalid:
+		// Do nothing.  We should never get here since invalid has already
+		// been handled above.
+
+	case reflect.Bool:
+		printBool(f.fs, v.Bool())
+
+	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+		printInt(f.fs, v.Int(), 10)
+
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+		printUint(f.fs, v.Uint(), 10)
+
+	case reflect.Float32:
+		printFloat(f.fs, v.Float(), 32)
+
+	case reflect.Float64:
+		printFloat(f.fs, v.Float(), 64)
+
+	case reflect.Complex64:
+		printComplex(f.fs, v.Complex(), 32)
+
+	case reflect.Complex128:
+		printComplex(f.fs, v.Complex(), 64)
+
+	case reflect.Slice:
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+		fallthrough
+
+	case reflect.Array:
+		f.fs.Write(openBracketBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			numEntries := v.Len()
+			for i := 0; i < numEntries; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.Index(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBracketBytes)
+
+	case reflect.String:
+		f.fs.Write([]byte(v.String()))
+
+	case reflect.Interface:
+		// The only time we should get here is for nil interfaces due to
+		// unpackValue calls.
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+		}
+
+	case reflect.Ptr:
+		// Do nothing.  We should never get here since pointers have already
+		// been handled above.
+
+	case reflect.Map:
+		// nil maps should be indicated as different than empty maps
+		if v.IsNil() {
+			f.fs.Write(nilAngleBytes)
+			break
+		}
+
+		f.fs.Write(openMapBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			keys := v.MapKeys()
+			if f.cs.SortKeys {
+				sortValues(keys, f.cs)
+			}
+			for i, key := range keys {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				f.ignoreNextType = true
+				f.format(f.unpackValue(key))
+				f.fs.Write(colonBytes)
+				f.ignoreNextType = true
+				f.format(f.unpackValue(v.MapIndex(key)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeMapBytes)
+
+	case reflect.Struct:
+		numFields := v.NumField()
+		f.fs.Write(openBraceBytes)
+		f.depth++
+		if (f.cs.MaxDepth != 0) && (f.depth > f.cs.MaxDepth) {
+			f.fs.Write(maxShortBytes)
+		} else {
+			vt := v.Type()
+			for i := 0; i < numFields; i++ {
+				if i > 0 {
+					f.fs.Write(spaceBytes)
+				}
+				vtf := vt.Field(i)
+				if f.fs.Flag('+') || f.fs.Flag('#') {
+					f.fs.Write([]byte(vtf.Name))
+					f.fs.Write(colonBytes)
+				}
+				f.format(f.unpackValue(v.Field(i)))
+			}
+		}
+		f.depth--
+		f.fs.Write(closeBraceBytes)
+
+	case reflect.Uintptr:
+		printHexPtr(f.fs, uintptr(v.Uint()))
+
+	case reflect.UnsafePointer, reflect.Chan, reflect.Func:
+		printHexPtr(f.fs, v.Pointer())
+
+	// There were not any other types at the time this code was written, but
+	// fall back to letting the default fmt package handle it if any get added.
+	default:
+		format := f.buildDefaultFormat()
+		if v.CanInterface() {
+			fmt.Fprintf(f.fs, format, v.Interface())
+		} else {
+			fmt.Fprintf(f.fs, format, v.String())
+		}
+	}
+}
+
+// Format satisfies the fmt.Formatter interface. See NewFormatter for usage
+// details.
+func (f *formatState) Format(fs fmt.State, verb rune) {
+	f.fs = fs
+
+	// Use standard formatting for verbs that are not v.
+	if verb != 'v' {
+		format := f.constructOrigFormat(verb)
+		fmt.Fprintf(fs, format, f.value)
+		return
+	}
+
+	if f.value == nil {
+		if fs.Flag('#') {
+			fs.Write(interfaceBytes)
+		}
+		fs.Write(nilAngleBytes)
+		return
+	}
+
+	f.format(reflect.ValueOf(f.value))
+}
+
+// newFormatter is a helper function to consolidate the logic from the various
+// public methods which take varying config states.
+func newFormatter(cs *ConfigState, v interface{}) fmt.Formatter {
+	fs := &formatState{value: v, cs: cs}
+	fs.pointers = make(map[uintptr]int)
+	return fs
+}
+
+/*
+NewFormatter returns a custom formatter that satisfies the fmt.Formatter
+interface.  As a result, it integrates cleanly with standard fmt package
+printing functions.  The formatter is useful for inline printing of smaller data
+types similar to the standard %v format specifier.
+
+The custom formatter only responds to the %v (most compact), %+v (adds pointer
+addresses), %#v (adds types), or %#+v (adds types and pointer addresses) verb
+combinations.  Any other verbs such as %x and %q will be sent to the the
+standard fmt package for formatting.  In addition, the custom formatter ignores
+the width and precision arguments (however they will still work on the format
+specifiers not handled by the custom formatter).
+
+Typically this function shouldn't be called directly.  It is much easier to make
+use of the custom formatter by calling one of the convenience functions such as
+Printf, Println, or Fprintf.
+*/
+func NewFormatter(v interface{}) fmt.Formatter {
+	return newFormatter(&Config, v)
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Wim	ad4d461606	Release v1.0.0	2017-08-05 15:50:21 +02:00
anon724	67905089ba	Add UseUserName option (discord) (#234 )	2017-08-01 18:18:55 +02:00
Wim	f2483af561	Do not modify username in action (discord)	2017-07-31 21:37:19 +02:00
Wim	c28b87641e	Release v1.0.0-rc1	2017-07-30 18:05:27 +02:00
Wim	f8e6a69d6e	Add action support for slack,mattermost,irc,gitter,matrix,xmpp,discord. #199	2017-07-30 17:48:23 +02:00
Wim	54216cec4b	Remove unused function	2017-07-30 16:12:33 +02:00
Wim	12989bbd99	Handle same account in multiple gateways better	2017-07-30 16:09:05 +02:00
Wim	38d09dba2e	Update vendor (go-irc)	2017-07-28 14:26:26 +02:00
Wim	fafd0c68e9	Update readme	2017-07-26 22:37:48 +02:00
Wim	41195c8e48	Fix double posting of edited messages by using lru cache (mattermost)	2017-07-25 23:57:27 +02:00
Wim	a97804548e	Add vendor (github.com/hashicorp/golang-lru)	2017-07-25 23:56:12 +02:00
Wim	ba653c0841	Ignore edited messages with reactions (mattermost)	2017-07-25 23:19:50 +02:00
Wim	5b191f78a0	Update tests with gofmt	2017-07-25 20:20:55 +02:00
Wim	83ef61287e	Refactor. Add tests	2017-07-25 20:11:52 +02:00
Wim	3527e09bc5	Update vendor	2017-07-25 20:10:40 +02:00
Wim	ddc5b3268f	Add screenshots	2017-07-24 17:36:57 +02:00
Wim	22307b1934	Release v0.16.3	2017-07-24 16:20:34 +02:00
Wim	bd97357f8d	Disable message from other bots when using webhooks (slack)	2017-07-22 20:03:40 +02:00
Wim	10dab1366e	Return better error messages on mattermost connect	2017-07-22 18:13:13 +02:00
Wim	52fc94c1fe	Remove old files. Update readme	2017-07-22 17:50:34 +02:00
Wim	c1c7961dd6	Fix in/out logic. Closes #224	2017-07-22 17:25:22 +02:00
Wim	d3eef051b1	Fix message modification	2017-07-21 17:04:03 +02:00
Wim	57654df81e	Bump version	2017-07-20 23:17:02 +02:00
Wim	0f791d7a9a	Handle reconnections better (xmpp). Closes #222	2017-07-20 23:16:43 +02:00
Wim	58779e0d65	Update readme	2017-07-19 00:31:26 +02:00
Wim	4ac361b5fd	Add xmpp badge	2017-07-19 00:29:46 +02:00
Wim	1e2f27c061	Release v0.16.2	2017-07-18 23:48:00 +02:00
Wim	0302e4da82	Fix webhookurl/webhookbindaddress panic (mattermost). Closes #221	2017-07-17 23:10:32 +02:00
Wim	dc8743e0c0	Tag messages we send ourself using CallbackID hack (slack). Closes #219	2017-07-17 21:28:31 +02:00
Jerry Heiselman	cc5ce3d5ae	Suppress parent message when child message is received (slack) (#218 ) * Suppress parent message when child message is received When a thread is started in Slack and a user makes a comment on the thread, matterbridge sends the original parent message again on each child comment. This change suppresses that. * Update slack.go Moved determination of ThreadTimestamp to handleSlackClient so the MMMessage struct doesn't need to be modified * Ran 'go fmt'	2017-07-17 18:33:28 +02:00
Wim	caaf6f3012	Fix stable/dev shields	2017-07-16 23:14:18 +02:00
Wim	c5de8fd1cc	Fix readme	2017-07-16 22:57:45 +02:00
Wim	c9f23869e3	Add stable/devel shields	2017-07-16 22:56:26 +02:00
Wim	61208c0e35	Update readme	2017-07-16 22:27:53 +02:00
Wim	dcffc74255	Set correct binaries path	2017-07-16 22:15:06 +02:00
Wim	23e23be1a6	Try travis bintray integration (6)	2017-07-16 22:06:33 +02:00
Wim	710427248a	Try travis bintray integration (5)	2017-07-16 22:02:46 +02:00
Wim	a868042de2	Try travis bintray integration (4)	2017-07-16 21:43:19 +02:00
Wim	15296cd8b4	Try travis bintray integration (3)	2017-07-16 21:32:41 +02:00
Wim	717023245f	Try travis bintray integration (2)	2017-07-16 21:05:29 +02:00
Wim	320be5bffa	Try travis bintray integration	2017-07-16 20:57:32 +02:00
Wim	778abea2d9	Add support for fallback/text in attachments (slack)	2017-07-16 18:08:26 +02:00
Wim	835a1ac3a6	Update travis for crossplatform	2017-07-16 17:15:00 +02:00
Wim	20a7ef33f1	Make sure bot doesn't loop now we relay bot messages (slack)	2017-07-16 15:03:46 +02:00
Wim	e72612c7ff	Bump version	2017-07-16 15:02:15 +02:00
Wim	04e0f001b0	Fix discordgo api changes	2017-07-16 14:39:00 +02:00
Wim	5db24aa901	Update vendor (bwmarrin/discordgo)	2017-07-16 14:38:45 +02:00
Wim	aec5e3d77b	Update vendor (nlopes/slack)	2017-07-16 14:29:46 +02:00
Wim	335ddf8db5	Fix lookup bot username (slack). #213	2017-07-16 14:18:33 +02:00
Wim	4abaf2b236	Fix mattermost shield	2017-07-16 00:47:29 +02:00
Wim	183d212431	Add mattermost chat/badge	2017-07-16 00:43:32 +02:00