Use mod vendor for vendored directory (backwards compatible)

8 files changed, 157 insertions, 970 deletions

diff --git a/vendor/github.com/42wim/go-gitter/.gitignore b/vendor/github.com/42wim/go-gitter/.gitignore
new file mode 100644
index 00000000..f8601221
--- /dev/null
+++ b/vendor/github.com/42wim/go-gitter/.gitignore
@@ -0,0 +1,3 @@
+.idea
+/test
+app.yaml
\ No newline at end of file
diff --git a/vendor/github.com/42wim/go-gitter/README.md b/vendor/github.com/42wim/go-gitter/README.md
new file mode 100644
index 00000000..5d58526d
--- /dev/null
+++ b/vendor/github.com/42wim/go-gitter/README.md
@@ -0,0 +1,154 @@
+# gitter
+Gitter API in Go
+https://developer.gitter.im
+
+#### Install
+
+`go get github.com/sromku/go-gitter`
+
+- [Initialize](#initialize)
+- [Users](#users)
+- [Rooms](#rooms)
+- [Messages](#messages)
+- [Stream](#stream)
+- [Faye (Experimental)](#faye-experimental)
+- [Debug](#debug)
+- [App Engine](#app-engine)
+
+##### Initialize
+``` Go
+api := gitter.New("YOUR_ACCESS_TOKEN")
+```
+
+##### Users
+
+- Get current user
+
+	``` Go
+	user, err := api.GetUser()
+	```
+
+##### Rooms
+
+- Get all rooms
+	``` Go
+	rooms, err := api.GetRooms()
+	```
+
+- Get room by id
+	``` Go
+	room, err := api.GetRoom("roomID")
+	```
+
+- Get rooms of some user
+	``` Go
+	rooms, err := api.GetRooms("userID")
+	```
+
+- Join room
+	``` Go
+	room, err := api.JoinRoom("roomID", "userID")
+	```
+	
+- Leave room
+	``` Go
+	room, err := api.LeaveRoom("roomID", "userID")
+	```
+
+- Get room id
+	``` Go
+	id, err := api.GetRoomId("room/uri")
+	```
+
+- Search gitter rooms
+	``` Go
+	rooms, err := api.SearchRooms("search/string")
+	```
+##### Messages
+
+- Get messages of room
+	``` Go
+	messages, err := api.GetMessages("roomID", nil)
+	```
+
+- Get one message
+	``` Go
+	message, err := api.GetMessage("roomID", "messageID")
+	```
+
+- Send message
+	``` Go
+	err := api.SendMessage("roomID", "free chat text")
+	```
+
+##### Stream
+
+Create stream to the room and start listening to incoming messages
+
+``` Go
+stream := api.Stream(room.Id)
+go api.Listen(stream)
+
+for {
+    event := <-stream.Event
+    switch ev := event.Data.(type) {
+    case *gitter.MessageReceived:
+        fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+    case *gitter.GitterConnectionClosed:
+        // connection was closed
+    }
+}
+```
+
+Close stream connection
+
+``` Go
+stream.Close()
+```
+
+##### Faye (Experimental)
+
+``` Go
+faye := api.Faye(room.ID)
+go faye.Listen()
+
+for {
+    event := <-faye.Event
+    switch ev := event.Data.(type) {
+    case *gitter.MessageReceived:
+        fmt.Println(ev.Message.From.Username + ": " + ev.Message.Text)
+    case *gitter.GitterConnectionClosed: //this one is never called in Faye
+        // connection was closed
+    }
+}
+```
+
+##### Debug
+
+You can print the internal errors by enabling debug to true
+
+``` Go
+api.SetDebug(true, nil)
+```
+
+You can also define your own `io.Writer` in case you want to persist the logs somewhere.
+For example keeping the errors on file
+
+``` Go
+logFile, err := os.Create("gitter.log")
+api.SetDebug(true, logFile)
+```
+
+##### App Engine
+
+Initialize app engine client and continue as usual
+
+``` Go
+c := appengine.NewContext(r)
+client := urlfetch.Client(c)
+
+api := gitter.New("YOUR_ACCESS_TOKEN")
+api.SetClient(client)
+```
+
+[Documentation](https://godoc.org/github.com/sromku/go-gitter)
diff --git a/vendor/github.com/42wim/go-ircevent/LICENSE b/vendor/github.com/42wim/go-ircevent/LICENSE
deleted file mode 100644
index d6bf3577..00000000
--- a/vendor/github.com/42wim/go-ircevent/LICENSE
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2009 Thomas Jager. All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions are
-// met:
-//
-//    * Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//    * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//    * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/github.com/42wim/go-ircevent/irc.go b/vendor/github.com/42wim/go-ircevent/irc.go
deleted file mode 100644
index ea9c1f05..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc.go
+++ /dev/null
@@ -1,578 +0,0 @@
-// Copyright 2009 Thomas Jager <mail@jager.no>  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-This package provides an event based IRC client library. It allows to
-register callbacks for the events you need to handle. Its features
-include handling standard CTCP, reconnecting on errors and detecting
-stones servers.
-Details of the IRC protocol can be found in the following RFCs:
-https://tools.ietf.org/html/rfc1459
-https://tools.ietf.org/html/rfc2810
-https://tools.ietf.org/html/rfc2811
-https://tools.ietf.org/html/rfc2812
-https://tools.ietf.org/html/rfc2813
-The details of the client-to-client protocol (CTCP) can be found here: http://www.irchelp.org/irchelp/rfc/ctcpspec.html
-*/
-
-package irc
-
-import (
-	"bufio"
-	"bytes"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"log"
-	"net"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-)
-
-const (
-	VERSION = "go-ircevent v2.1"
-)
-
-var ErrDisconnected = errors.New("Disconnect Called")
-
-// Read data from a connection. To be used as a goroutine.
-func (irc *Connection) readLoop() {
-	defer irc.Done()
-	br := bufio.NewReaderSize(irc.socket, 512)
-
-	errChan := irc.ErrorChan()
-
-	for {
-		select {
-		case <-irc.end:
-			return
-		default:
-			// Set a read deadline based on the combined timeout and ping frequency
-			// We should ALWAYS have received a response from the server within the timeout
-			// after our own pings
-			if irc.socket != nil {
-				irc.socket.SetReadDeadline(time.Now().Add(irc.Timeout + irc.PingFreq))
-			}
-
-			msg, err := br.ReadString('\n')
-
-			// We got past our blocking read, so bin timeout
-			if irc.socket != nil {
-				var zero time.Time
-				irc.socket.SetReadDeadline(zero)
-			}
-
-			if err != nil {
-				errChan <- err
-				return
-			}
-
-			if irc.Debug {
-				irc.Log.Printf("<-- %s\n", strings.TrimSpace(msg))
-			}
-
-			irc.Lock()
-			irc.lastMessage = time.Now()
-			irc.Unlock()
-			event, err := parseToEvent(msg)
-			event.Connection = irc
-			if err == nil {
-				/* XXX: len(args) == 0: args should be empty */
-				irc.RunCallbacks(event)
-			}
-		}
-	}
-}
-
-// 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
-	msg = strings.TrimSuffix(msg, "\r")
-	event := &Event{Raw: msg}
-	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]
-			msg = msg[i+1 : len(msg)]
-
-		} else {
-			return nil, errors.New("Malformed msg from server")
-		}
-
-		if i, j := strings.Index(event.Source, "!"), strings.Index(event.Source, "@"); i > -1 && j > -1 && i < j {
-			event.Nick = event.Source[0:i]
-			event.User = event.Source[i+1 : j]
-			event.Host = event.Source[j+1 : len(event.Source)]
-		}
-	}
-
-	split := strings.SplitN(msg, " :", 2)
-	args := strings.Split(split[0], " ")
-	event.Code = strings.ToUpper(args[0])
-	event.Arguments = args[1:]
-	if len(split) > 1 {
-		event.Arguments = append(event.Arguments, split[1])
-	}
-	return event, nil
-
-}
-
-// Loop to write to a connection. To be used as a goroutine.
-func (irc *Connection) writeLoop() {
-	defer irc.Done()
-	errChan := irc.ErrorChan()
-	for {
-		select {
-		case <-irc.end:
-			return
-		case b, ok := <-irc.pwrite:
-			if !ok || b == "" || irc.socket == nil {
-				return
-			}
-
-			if irc.Debug {
-				irc.Log.Printf("--> %s\n", strings.TrimSpace(b))
-			}
-
-			// Set a write deadline based on the time out
-			irc.socket.SetWriteDeadline(time.Now().Add(irc.Timeout))
-
-			_, err := irc.socket.Write([]byte(b))
-
-			// Past blocking write, bin timeout
-			var zero time.Time
-			irc.socket.SetWriteDeadline(zero)
-
-			if err != nil {
-				errChan <- err
-				return
-			}
-		}
-	}
-}
-
-// Pings the server if we have not received any messages for 5 minutes
-// to keep the connection alive. To be used as a goroutine.
-func (irc *Connection) pingLoop() {
-	defer irc.Done()
-	ticker := time.NewTicker(1 * time.Minute) // Tick every minute for monitoring
-	ticker2 := time.NewTicker(irc.PingFreq)   // Tick at the ping frequency.
-	for {
-		select {
-		case <-ticker.C:
-			//Ping if we haven't received anything from the server within the keep alive period
-			if time.Since(irc.lastMessage) >= irc.KeepAlive {
-				irc.SendRawf("PING %d", time.Now().UnixNano())
-			}
-		case <-ticker2.C:
-			//Ping at the ping frequency
-			irc.SendRawf("PING %d", time.Now().UnixNano())
-			//Try to recapture nickname if it's not as configured.
-			irc.Lock()
-			if irc.nick != irc.nickcurrent {
-				irc.nickcurrent = irc.nick
-				irc.SendRawf("NICK %s", irc.nick)
-			}
-			irc.Unlock()
-		case <-irc.end:
-			ticker.Stop()
-			ticker2.Stop()
-			return
-		}
-	}
-}
-
-func (irc *Connection) isQuitting() bool {
-	irc.Lock()
-	defer irc.Unlock()
-	return irc.quit
-}
-
-// Main loop to control the connection.
-func (irc *Connection) Loop() {
-	errChan := irc.ErrorChan()
-	connTime := time.Now()
-	for !irc.isQuitting() {
-		err := <-errChan
-		close(irc.end)
-		irc.Wait()
-		for !irc.isQuitting() {
-			irc.Log.Printf("Error, disconnected: %s\n", err)
-			if time.Now().Sub(connTime) < time.Second*5 {
-				irc.Log.Println("Rreconnecting too fast, sleeping 60 seconds")
-				time.Sleep(60 * time.Second)
-			}
-			if err = irc.Reconnect(); err != nil {
-				irc.Log.Printf("Error while reconnecting: %s\n", err)
-				time.Sleep(60 * time.Second)
-			} else {
-				errChan = irc.ErrorChan()
-				break
-			}
-		}
-		connTime = time.Now()
-	}
-}
-
-// Quit the current connection and disconnect from the server
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1.6
-func (irc *Connection) Quit() {
-	quit := "QUIT"
-
-	if irc.QuitMessage != "" {
-		quit = fmt.Sprintf("QUIT :%s", irc.QuitMessage)
-	}
-
-	irc.SendRaw(quit)
-	irc.Lock()
-	irc.stopped = true
-	irc.quit = true
-	irc.Unlock()
-}
-
-// Use the connection to join a given channel.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.1
-func (irc *Connection) Join(channel string) {
-	irc.pwrite <- fmt.Sprintf("JOIN %s\r\n", channel)
-}
-
-// Leave a given channel.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.2
-func (irc *Connection) Part(channel string) {
-	irc.pwrite <- fmt.Sprintf("PART %s\r\n", channel)
-}
-
-// Send a notification to a nickname. This is similar to Privmsg but must not receive replies.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.2
-func (irc *Connection) Notice(target, message string) {
-	irc.pwrite <- fmt.Sprintf("NOTICE %s :%s\r\n", target, message)
-}
-
-// Send a formated notification to a nickname.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.2
-func (irc *Connection) Noticef(target, format string, a ...interface{}) {
-	irc.Notice(target, fmt.Sprintf(format, a...))
-}
-
-// Send (action) message to a target (channel or nickname).
-// No clear RFC on this one...
-func (irc *Connection) Action(target, message string) {
-	irc.pwrite <- fmt.Sprintf("PRIVMSG %s :\001ACTION %s\001\r\n", target, message)
-}
-
-// Send formatted (action) message to a target (channel or nickname).
-func (irc *Connection) Actionf(target, format string, a ...interface{}) {
-	irc.Action(target, fmt.Sprintf(format, a...))
-}
-
-// Send (private) message to a target (channel or nickname).
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.4.1
-func (irc *Connection) Privmsg(target, message string) {
-	irc.pwrite <- fmt.Sprintf("PRIVMSG %s :%s\r\n", target, message)
-}
-
-// Send formated string to specified target (channel or nickname).
-func (irc *Connection) Privmsgf(target, format string, a ...interface{}) {
-	irc.Privmsg(target, fmt.Sprintf(format, a...))
-}
-
-// Kick <user> from <channel> with <msg>. For no message, pass empty string ("")
-func (irc *Connection) Kick(user, channel, msg string) {
-	var cmd bytes.Buffer
-	cmd.WriteString(fmt.Sprintf("KICK %s %s", channel, user))
-	if msg != "" {
-		cmd.WriteString(fmt.Sprintf(" :%s", msg))
-	}
-	cmd.WriteString("\r\n")
-	irc.pwrite <- cmd.String()
-}
-
-// Kick all <users> from <channel> with <msg>. For no message, pass
-// empty string ("")
-func (irc *Connection) MultiKick(users []string, channel string, msg string) {
-	var cmd bytes.Buffer
-	cmd.WriteString(fmt.Sprintf("KICK %s %s", channel, strings.Join(users, ",")))
-	if msg != "" {
-		cmd.WriteString(fmt.Sprintf(" :%s", msg))
-	}
-	cmd.WriteString("\r\n")
-	irc.pwrite <- cmd.String()
-}
-
-// Send raw string.
-func (irc *Connection) SendRaw(message string) {
-	irc.pwrite <- message + "\r\n"
-}
-
-// Send raw formated string.
-func (irc *Connection) SendRawf(format string, a ...interface{}) {
-	irc.SendRaw(fmt.Sprintf(format, a...))
-}
-
-// Set (new) nickname.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1.2
-func (irc *Connection) Nick(n string) {
-	irc.nick = n
-	irc.SendRawf("NICK %s", n)
-}
-
-// Determine nick currently used with the connection.
-func (irc *Connection) GetNick() string {
-	return irc.nickcurrent
-}
-
-// Query information about a particular nickname.
-// RFC 1459: https://tools.ietf.org/html/rfc1459#section-4.5.2
-func (irc *Connection) Whois(nick string) {
-	irc.SendRawf("WHOIS %s", nick)
-}
-
-// Query information about a given nickname in the server.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.5.1
-func (irc *Connection) Who(nick string) {
-	irc.SendRawf("WHO %s", nick)
-}
-
-// Set different modes for a target (channel or nickname).
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.2.3
-func (irc *Connection) Mode(target string, modestring ...string) {
-	if len(modestring) > 0 {
-		mode := strings.Join(modestring, " ")
-		irc.SendRawf("MODE %s %s", target, mode)
-		return
-	}
-	irc.SendRawf("MODE %s", target)
-}
-
-func (irc *Connection) ErrorChan() chan error {
-	return irc.Error
-}
-
-// Returns true if the connection is connected to an IRC server.
-func (irc *Connection) Connected() bool {
-	return !irc.stopped
-}
-
-// A disconnect sends all buffered messages (if possible),
-// stops all goroutines and then closes the socket.
-func (irc *Connection) Disconnect() {
-	if irc.socket != nil {
-		irc.socket.Close()
-	}
-	irc.ErrorChan() <- ErrDisconnected
-}
-
-// Reconnect to a server using the current connection.
-func (irc *Connection) Reconnect() error {
-	irc.end = make(chan struct{})
-	return irc.Connect(irc.Server)
-}
-
-// Connect to a given server using the current connection configuration.
-// This function also takes care of identification if a password is provided.
-// RFC 1459 details: https://tools.ietf.org/html/rfc1459#section-4.1
-func (irc *Connection) Connect(server string) error {
-	irc.Server = server
-	// mark Server as stopped since there can be an error during connect
-	irc.stopped = true
-
-	// make sure everything is ready for connection
-	if len(irc.Server) == 0 {
-		return errors.New("empty 'server'")
-	}
-	if strings.Count(irc.Server, ":") != 1 {
-		return errors.New("wrong number of ':' in address")
-	}
-	if strings.Index(irc.Server, ":") == 0 {
-		return errors.New("hostname is missing")
-	}
-	if strings.Index(irc.Server, ":") == len(irc.Server)-1 {
-		return errors.New("port missing")
-	}
-	// check for valid range
-	ports := strings.Split(irc.Server, ":")[1]
-	port, err := strconv.Atoi(ports)
-	if err != nil {
-		return errors.New("extracting port failed")
-	}
-	if !((port >= 0) && (port <= 65535)) {
-		return errors.New("port number outside valid range")
-	}
-	if irc.Log == nil {
-		return errors.New("'Log' points to nil")
-	}
-	if len(irc.nick) == 0 {
-		return errors.New("empty 'nick'")
-	}
-	if len(irc.user) == 0 {
-		return errors.New("empty 'user'")
-	}
-
-	if irc.UseTLS {
-		dialer := &net.Dialer{Timeout: irc.Timeout}
-		irc.socket, err = tls.DialWithDialer(dialer, "tcp", irc.Server, irc.TLSConfig)
-	} else {
-		irc.socket, err = net.DialTimeout("tcp", irc.Server, irc.Timeout)
-	}
-	if err != nil {
-		return err
-	}
-
-	irc.stopped = false
-	irc.Log.Printf("Connected to %s (%s)\n", irc.Server, irc.socket.RemoteAddr())
-
-	irc.pwrite = make(chan string, 10)
-	irc.Error = make(chan error, 2)
-	irc.Add(3)
-	go irc.readLoop()
-	go irc.writeLoop()
-	go irc.pingLoop()
-	if len(irc.Password) > 0 {
-		irc.pwrite <- fmt.Sprintf("PASS %s\r\n", irc.Password)
-	}
-
-	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 {
-		select {
-		case res := <-saslResChan:
-			if res.Failed {
-				close(saslResChan)
-				return res.Err
-			}
-		case <-time.After(time.Second * 15):
-			close(saslResChan)
-			return errors.New("SASL setup timed out. This shouldn't happen.")
-		}
-	}
-
-	// 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
-}
-
-// Create a connection with the (publicly visible) nickname and username.
-// The nickname is later used to address the user. Returns nil if nick
-// or user are empty.
-func IRC(nick, user string) *Connection {
-	// catch invalid values
-	if len(nick) == 0 {
-		return nil
-	}
-	if len(user) == 0 {
-		return nil
-	}
-
-	irc := &Connection{
-		nick:        nick,
-		nickcurrent: nick,
-		user:        user,
-		Log:         log.New(os.Stdout, "", log.LstdFlags),
-		end:         make(chan struct{}),
-		Version:     VERSION,
-		KeepAlive:   4 * time.Minute,
-		Timeout:     1 * time.Minute,
-		PingFreq:    15 * time.Minute,
-		SASLMech:    "PLAIN",
-		QuitMessage: "",
-	}
-	irc.setupCallbacks()
-	return irc
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_callback.go b/vendor/github.com/42wim/go-ircevent/irc_callback.go
deleted file mode 100644
index d389f731..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_callback.go
+++ /dev/null
@@ -1,222 +0,0 @@
-package irc
-
-import (
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Register a callback to a connection and event code. A callback is a function
-// which takes only an Event pointer as parameter. Valid event codes are all
-// IRC/CTCP commands and error/response codes. This function returns the ID of
-// the registered callback for later management.
-func (irc *Connection) AddCallback(eventcode string, callback func(*Event)) int {
-	eventcode = strings.ToUpper(eventcode)
-	id := 0
-	if _, ok := irc.events[eventcode]; !ok {
-		irc.events[eventcode] = make(map[int]func(*Event))
-		id = 0
-	} else {
-		id = len(irc.events[eventcode])
-	}
-	irc.events[eventcode][id] = callback
-	return id
-}
-
-// Remove callback i (ID) from the given event code. This functions returns
-// true upon success, false if any error occurs.
-func (irc *Connection) RemoveCallback(eventcode string, i int) bool {
-	eventcode = strings.ToUpper(eventcode)
-
-	if event, ok := irc.events[eventcode]; ok {
-		if _, ok := event[i]; ok {
-			delete(irc.events[eventcode], i)
-			return true
-		}
-		irc.Log.Printf("Event found, but no callback found at id %d\n", i)
-		return false
-	}
-
-	irc.Log.Println("Event not found")
-	return false
-}
-
-// Remove all callbacks from a given event code. It returns true
-// if given event code is found and cleared.
-func (irc *Connection) ClearCallback(eventcode string) bool {
-	eventcode = strings.ToUpper(eventcode)
-
-	if _, ok := irc.events[eventcode]; ok {
-		irc.events[eventcode] = make(map[int]func(*Event))
-		return true
-	}
-
-	irc.Log.Println("Event not found")
-	return false
-}
-
-// Replace callback i (ID) associated with a given event code with a new callback function.
-func (irc *Connection) ReplaceCallback(eventcode string, i int, callback func(*Event)) {
-	eventcode = strings.ToUpper(eventcode)
-
-	if event, ok := irc.events[eventcode]; ok {
-		if _, ok := event[i]; ok {
-			event[i] = callback
-			return
-		}
-		irc.Log.Printf("Event found, but no callback found at id %d\n", i)
-	}
-	irc.Log.Printf("Event not found. Use AddCallBack\n")
-}
-
-// Execute all callbacks associated with a given event.
-func (irc *Connection) RunCallbacks(event *Event) {
-	msg := event.Message()
-	if event.Code == "PRIVMSG" && len(msg) > 2 && msg[0] == '\x01' {
-		event.Code = "CTCP" //Unknown CTCP
-
-		if i := strings.LastIndex(msg, "\x01"); i > 0 {
-			msg = msg[1:i]
-		} else {
-			irc.Log.Printf("Invalid CTCP Message: %s\n", strconv.Quote(msg))
-			return
-		}
-
-		if msg == "VERSION" {
-			event.Code = "CTCP_VERSION"
-
-		} else if msg == "TIME" {
-			event.Code = "CTCP_TIME"
-
-		} else if strings.HasPrefix(msg, "PING") {
-			event.Code = "CTCP_PING"
-
-		} else if msg == "USERINFO" {
-			event.Code = "CTCP_USERINFO"
-
-		} else if msg == "CLIENTINFO" {
-			event.Code = "CTCP_CLIENTINFO"
-
-		} else if strings.HasPrefix(msg, "ACTION") {
-			event.Code = "CTCP_ACTION"
-			if len(msg) > 6 {
-				msg = msg[7:]
-			} else {
-				msg = ""
-			}
-		}
-
-		event.Arguments[len(event.Arguments)-1] = msg
-	}
-
-	if callbacks, ok := irc.events[event.Code]; ok {
-		if irc.VerboseCallbackHandler {
-			irc.Log.Printf("%v (%v) >> %#v\n", event.Code, len(callbacks), event)
-		}
-
-		for _, callback := range callbacks {
-			callback(event)
-		}
-	} else if irc.VerboseCallbackHandler {
-		irc.Log.Printf("%v (0) >> %#v\n", event.Code, event)
-	}
-
-	if callbacks, ok := irc.events["*"]; ok {
-		if irc.VerboseCallbackHandler {
-			irc.Log.Printf("%v (0) >> %#v\n", event.Code, event)
-		}
-
-		for _, callback := range callbacks {
-			callback(event)
-		}
-	}
-}
-
-// Set up some initial callbacks to handle the IRC/CTCP protocol.
-func (irc *Connection) setupCallbacks() {
-	irc.events = make(map[string]map[int]func(*Event))
-
-	//Handle error events.
-	irc.AddCallback("ERROR", func(e *Event) { irc.Disconnect() })
-
-	//Handle ping events
-	irc.AddCallback("PING", func(e *Event) { irc.SendRaw("PONG :" + e.Message()) })
-
-	//Version handler
-	irc.AddCallback("CTCP_VERSION", func(e *Event) {
-		irc.SendRawf("NOTICE %s :\x01VERSION %s\x01", e.Nick, irc.Version)
-	})
-
-	irc.AddCallback("CTCP_USERINFO", func(e *Event) {
-		irc.SendRawf("NOTICE %s :\x01USERINFO %s\x01", e.Nick, irc.user)
-	})
-
-	irc.AddCallback("CTCP_CLIENTINFO", func(e *Event) {
-		irc.SendRawf("NOTICE %s :\x01CLIENTINFO PING VERSION TIME USERINFO CLIENTINFO\x01", e.Nick)
-	})
-
-	irc.AddCallback("CTCP_TIME", func(e *Event) {
-		ltime := time.Now()
-		irc.SendRawf("NOTICE %s :\x01TIME %s\x01", e.Nick, ltime.String())
-	})
-
-	irc.AddCallback("CTCP_PING", func(e *Event) { irc.SendRawf("NOTICE %s :\x01%s\x01", e.Nick, e.Message()) })
-
-	// 437: ERR_UNAVAILRESOURCE "<nick/channel> :Nick/channel is temporarily unavailable"
-	// Add a _ to current nick. If irc.nickcurrent is empty this cannot
-	// work. It has to be set somewhere first in case the nick is already
-	// taken or unavailable from the beginning.
-	irc.AddCallback("437", func(e *Event) {
-		// If irc.nickcurrent hasn't been set yet, set to irc.nick
-		if irc.nickcurrent == "" {
-			irc.nickcurrent = irc.nick
-		}
-
-		if len(irc.nickcurrent) > 8 {
-			irc.nickcurrent = "_" + irc.nickcurrent
-		} else {
-			irc.nickcurrent = irc.nickcurrent + "_"
-		}
-		irc.SendRawf("NICK %s", irc.nickcurrent)
-	})
-
-	// 433: ERR_NICKNAMEINUSE "<nick> :Nickname is already in use"
-	// Add a _ to current nick.
-	irc.AddCallback("433", func(e *Event) {
-		// If irc.nickcurrent hasn't been set yet, set to irc.nick
-		if irc.nickcurrent == "" {
-			irc.nickcurrent = irc.nick
-		}
-
-		if len(irc.nickcurrent) > 8 {
-			irc.nickcurrent = "_" + irc.nickcurrent
-		} else {
-			irc.nickcurrent = irc.nickcurrent + "_"
-		}
-		irc.SendRawf("NICK %s", irc.nickcurrent)
-	})
-
-	irc.AddCallback("PONG", func(e *Event) {
-		ns, _ := strconv.ParseInt(e.Message(), 10, 64)
-		delta := time.Duration(time.Now().UnixNano() - ns)
-		if irc.Debug {
-			irc.Log.Printf("Lag: %.3f s\n", delta.Seconds())
-		}
-	})
-
-	// NICK Define a nickname.
-	// Set irc.nickcurrent to the new nick actually used in this connection.
-	irc.AddCallback("NICK", func(e *Event) {
-		if e.Nick == irc.nick {
-			irc.nickcurrent = e.Message()
-		}
-	})
-
-	// 1: RPL_WELCOME "Welcome to the Internet Relay Network <nick>!<user>@<host>"
-	// Set irc.nickcurrent to the actually used nick in this connection.
-	irc.AddCallback("001", func(e *Event) {
-		irc.Lock()
-		irc.nickcurrent = e.Arguments[0]
-		irc.Unlock()
-	})
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_sasl.go b/vendor/github.com/42wim/go-ircevent/irc_sasl.go
deleted file mode 100644
index fd9df7ba..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_sasl.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package irc
-
-import (
-	"encoding/base64"
-	"errors"
-	"fmt"
-	"strings"
-)
-
-type SASLResult struct {
-	Failed bool
-	Err    error
-}
-
-func (irc *Connection) setupSASLCallbacks(result chan<- *SASLResult) {
-	irc.AddCallback("CAP", func(e *Event) {
-		if len(e.Arguments) == 3 {
-			if e.Arguments[1] == "LS" {
-				if !strings.Contains(e.Arguments[2], "sasl") {
-					result <- &SASLResult{true, errors.New("no SASL capability " + e.Arguments[2])}
-				}
-			}
-			if e.Arguments[1] == "ACK" {
-				if irc.SASLMech != "PLAIN" {
-					result <- &SASLResult{true, errors.New("only PLAIN is supported")}
-				}
-				irc.SendRaw("AUTHENTICATE " + irc.SASLMech)
-			}
-		}
-	})
-	irc.AddCallback("AUTHENTICATE", func(e *Event) {
-		str := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s\x00%s\x00%s", irc.SASLLogin, irc.SASLLogin, irc.SASLPassword)))
-		irc.SendRaw("AUTHENTICATE " + str)
-	})
-	irc.AddCallback("901", func(e *Event) {
-		irc.SendRaw("CAP END")
-		irc.SendRaw("QUIT")
-		result <- &SASLResult{true, errors.New(e.Arguments[1])}
-	})
-	irc.AddCallback("902", func(e *Event) {
-		irc.SendRaw("CAP END")
-		irc.SendRaw("QUIT")
-		result <- &SASLResult{true, errors.New(e.Arguments[1])}
-	})
-	irc.AddCallback("903", func(e *Event) {
-		result <- &SASLResult{false, nil}
-	})
-	irc.AddCallback("904", func(e *Event) {
-		irc.SendRaw("CAP END")
-		irc.SendRaw("QUIT")
-		result <- &SASLResult{true, errors.New(e.Arguments[1])}
-	})
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_struct.go b/vendor/github.com/42wim/go-ircevent/irc_struct.go
deleted file mode 100644
index c064cb80..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_struct.go
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2009 Thomas Jager <mail@jager.no>  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package irc
-
-import (
-	"crypto/tls"
-	"log"
-	"net"
-	"sync"
-	"time"
-)
-
-type Connection struct {
-	sync.Mutex
-	sync.WaitGroup
-	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
-	end    chan struct{}
-
-	nick        string //The nickname we want.
-	nickcurrent string //The nickname we currently have.
-	user        string
-	registered  bool
-	events      map[string]map[int]func(*Event)
-
-	QuitMessage string
-	lastMessage time.Time
-
-	VerboseCallbackHandler bool
-	Log                    *log.Logger
-
-	stopped bool
-	quit    bool //User called Quit, do not reconnect.
-}
-
-// A struct to represent an event.
-type Event struct {
-	Code       string
-	Raw        string
-	Nick       string //<nick>
-	Host       string //<nick>!<usr>@<host>
-	Source     string //<host>
-	User       string //<usr>
-	Arguments  []string
-	Tags       map[string]string
-	Connection *Connection
-}
-
-// Retrieve the last message from Event arguments.
-// This function  leaves the arguments untouched and
-// returns an empty string if there are none.
-func (e *Event) Message() string {
-	if len(e.Arguments) == 0 {
-		return ""
-	}
-	return e.Arguments[len(e.Arguments)-1]
-}
diff --git a/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go b/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
deleted file mode 100644
index 82202e1c..00000000
--- a/vendor/github.com/42wim/go-ircevent/irc_test_fuzz.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// +build gofuzz
-
-package irc
-
-func Fuzz(data []byte) int {
-	b := bytes.NewBuffer(data)
-	event, err := parseToEvent(b.String())
-	if err == nil {
-		irc := IRC("go-eventirc", "go-eventirc")
-		irc.RunCallbacks(event)
-		return 1
-	}
-	return 0
-}