From 8e16f59b5f00ea5d865f59bdc084d9bc2fdae178 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Fri, 15 Feb 2013 19:24:10 -0800
Subject: [PATCH 01/13] Use the internal event handling for initial
 pass/user/nick messages. Added constants for internal and named events.
 gofmt'ed all files and updated client.go/documentation.

---
 README.md                 |  4 +--
 client.go                 | 12 ++++---
 client/commands.go        | 75 +++++++++++++++++++++++++++------------
 client/commands_test.go   |  6 ++++
 client/connection.go      | 23 ++++++------
 client/connection_test.go | 20 ++++++-----
 client/dispatch.go        |  4 ++-
 client/dispatch_test.go   | 20 +++++------
 client/handlers.go        | 32 +++++++++++------
 client/handlers_test.go   |  8 ++---
 client/line.go            | 10 +++---
 client/line_test.go       | 14 ++++----
 client/state_handlers.go  | 24 ++++++-------
 13 files changed, 154 insertions(+), 98 deletions(-)

diff --git a/README.md b/README.md
index 5f22864..ea53fd9 100644
--- a/README.md
+++ b/README.md
@@ -24,11 +24,11 @@ Synopsis:
 
 		// Add handlers to do things here!
 		// e.g. join a channel on connect.
-		c.AddHandler("connected",
+		c.HandleFunc(irc.CONNECTED,
 			func(conn *irc.Conn, line *irc.Line) { conn.Join("#channel") })
 		// And a signal on disconnect
 		quit := make(chan bool)
-		c.AddHandler("disconnected",
+		c.HandleFunc(irc.DISCONNECTED,
 			func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
 		// Tell client to connect
diff --git a/client.go b/client.go
index cb8d02f..0ff9d18 100644
--- a/client.go
+++ b/client.go
@@ -1,11 +1,11 @@
 package main
 
 import (
-	irc "github.com/fluffle/goirc/client"
+	"bufio"
 	"flag"
 	"fmt"
+	irc "github.com/fluffle/goirc/client"
 	"os"
-	"bufio"
 	"strings"
 )
 
@@ -16,14 +16,14 @@ func main() {
 	flag.Parse()
 
 	// create new IRC connection
-	c := irc.SimpleClient("GoTest", "gotest")
+	c := irc.Client("GoTest", "gotest")
 	c.EnableStateTracking()
-	c.AddHandler("connected",
+	c.HandleFunc(irc.CONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { conn.Join(*channel) })
 
 	// Set up a handler to notify of disconnect events.
 	quit := make(chan bool)
-	c.AddHandler("disconnected",
+	c.HandleFunc(irc.DISCONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
 	// set up a goroutine to read commands from stdin
@@ -36,6 +36,8 @@ func main() {
 			if err != nil {
 				// wha?, maybe ctrl-D...
 				close(in)
+				reallyquit = true
+				c.Quit("")
 				break
 			}
 			// no point in sending empty lines down the channel
diff --git a/client/commands.go b/client/commands.go
index 870b6a1..f620f61 100644
--- a/client/commands.go
+++ b/client/commands.go
@@ -2,6 +2,34 @@ package client
 
 import "strings"
 
+const (
+	INIT         = "init"
+	CONNECTED    = "connected"
+	DISCONNECTED = "disconnected"
+	ACTION       = "ACTION"
+	AWAY         = "AWAY"
+	CTCP         = "CTCP"
+	CTCPREPLY    = "CTCPREPLY"
+	INVITE       = "INVITE"
+	JOIN         = "JOIN"
+	KICK         = "KICK"
+	MODE         = "MODE"
+	NICK         = "NICK"
+	NOTICE       = "NOTICE"
+	OPER         = "OPER"
+	PART         = "PART"
+	PASS         = "PASS"
+	PING         = "PING"
+	PONG         = "PONG"
+	PRIVMSG      = "PRIVMSG"
+	QUIT         = "QUIT"
+	TOPIC        = "TOPIC"
+	USER         = "USER"
+	VERSION      = "VERSION"
+	WHO          = "WHO"
+	WHOIS        = "WHOIS"
+)
+
 // this file contains the various commands you can
 // send to the server using an Conn connection
 
@@ -14,18 +42,18 @@ import "strings"
 func (conn *Conn) Raw(rawline string) { conn.out <- rawline }
 
 // Pass() sends a PASS command to the server
-func (conn *Conn) Pass(password string) { conn.out <- "PASS " + password }
+func (conn *Conn) Pass(password string) { conn.out <- PASS + " " + password }
 
 // Nick() sends a NICK command to the server
-func (conn *Conn) Nick(nick string) { conn.out <- "NICK " + nick }
+func (conn *Conn) Nick(nick string) { conn.out <- NICK + " " + nick }
 
 // User() sends a USER command to the server
 func (conn *Conn) User(ident, name string) {
-	conn.out <- "USER " + ident + " 12 * :" + name
+	conn.out <- USER + " " + ident + " 12 * :" + name
 }
 
 // Join() sends a JOIN command to the server
-func (conn *Conn) Join(channel string) { conn.out <- "JOIN " + channel }
+func (conn *Conn) Join(channel string) { conn.out <- JOIN + " " + channel }
 
 // Part() sends a PART command to the server with an optional part message
 func (conn *Conn) Part(channel string, message ...string) {
@@ -33,7 +61,7 @@ func (conn *Conn) Part(channel string, message ...string) {
 	if msg != "" {
 		msg = " :" + msg
 	}
-	conn.out <- "PART " + channel + msg
+	conn.out <- PART + " " + channel + msg
 }
 
 // Kick() sends a KICK command to remove a nick from a channel
@@ -42,7 +70,7 @@ func (conn *Conn) Kick(channel, nick string, message ...string) {
 	if msg != "" {
 		msg = " :" + msg
 	}
-	conn.out <- "KICK " + channel + " " + nick + msg
+	conn.out <- KICK + " " + channel + " " + nick + msg
 }
 
 // Quit() sends a QUIT command to the server with an optional quit message
@@ -51,20 +79,20 @@ func (conn *Conn) Quit(message ...string) {
 	if msg == "" {
 		msg = "GoBye!"
 	}
-	conn.out <- "QUIT :" + msg
+	conn.out <- QUIT + " :" + msg
 }
 
 // Whois() sends a WHOIS command to the server
-func (conn *Conn) Whois(nick string) { conn.out <- "WHOIS " + nick }
+func (conn *Conn) Whois(nick string) { conn.out <- WHOIS + " " + nick }
 
 //Who() sends a WHO command to the server
-func (conn *Conn) Who(nick string) { conn.out <- "WHO " + nick }
+func (conn *Conn) Who(nick string) { conn.out <- WHO + " " + nick }
 
 // Privmsg() sends a PRIVMSG to the target t
-func (conn *Conn) Privmsg(t, msg string) { conn.out <- "PRIVMSG " + t + " :" + msg }
+func (conn *Conn) Privmsg(t, msg string) { conn.out <- PRIVMSG + " " + t + " :" + msg }
 
 // Notice() sends a NOTICE to the target t
-func (conn *Conn) Notice(t, msg string) { conn.out <- "NOTICE " + t + " :" + msg }
+func (conn *Conn) Notice(t, msg string) { conn.out <- NOTICE + " " + t + " :" + msg }
 
 // Ctcp() sends a (generic) CTCP message to the target t
 // with an optional argument
@@ -87,10 +115,10 @@ func (conn *Conn) CtcpReply(t, ctcp string, arg ...string) {
 }
 
 // Version() sends a CTCP "VERSION" to the target t
-func (conn *Conn) Version(t string) { conn.Ctcp(t, "VERSION") }
+func (conn *Conn) Version(t string) { conn.Ctcp(t, VERSION) }
 
 // Action() sends a CTCP "ACTION" to the target t
-func (conn *Conn) Action(t, msg string) { conn.Ctcp(t, "ACTION", msg) }
+func (conn *Conn) Action(t, msg string) { conn.Ctcp(t, ACTION, msg) }
 
 // Topic() sends a TOPIC command to the channel
 //   Topic(channel) retrieves the current channel topic (see "332" handler)
@@ -100,7 +128,7 @@ func (conn *Conn) Topic(channel string, topic ...string) {
 	if t != "" {
 		t = " :" + t
 	}
-	conn.out <- "TOPIC " + channel + t
+	conn.out <- TOPIC + " " + channel + t
 }
 
 // Mode() sends a MODE command to the server. This one can get complicated if
@@ -115,7 +143,7 @@ func (conn *Conn) Mode(t string, modestring ...string) {
 	if mode != "" {
 		mode = " " + mode
 	}
-	conn.out <- "MODE " + t + mode
+	conn.out <- MODE + " " + t + mode
 }
 
 // Away() sends an AWAY command to the server
@@ -126,15 +154,18 @@ func (conn *Conn) Away(message ...string) {
 	if msg != "" {
 		msg = " :" + msg
 	}
-	conn.out <- "AWAY" + msg
+	conn.out <- AWAY + msg
 }
 
 // Invite() sends an INVITE command to the server
-func (conn *Conn) Invite(nick, channel string) {
-	conn.out <- "INVITE " + nick + " " + channel
-}
+func (conn *Conn) Invite(nick, channel string) { conn.out <- INVITE + " " + nick + " " + channel }
 
 // Oper() sends an OPER command to the server
-func (conn *Conn) Oper(user, pass string) {
-	conn.out <- "OPER " + user + " " + pass
-}
+func (conn *Conn) Oper(user, pass string) { conn.out <- OPER + " " + user + " " + pass }
+
+// Ping() sends a PING command to the server
+// A PONG response is to be expected afterwards
+func (conn *Conn) Ping(message string) { conn.out <- PING + " :" + message }
+
+// Pong() sends a PONG command to the server
+func (conn *Conn) Pong(message string) { conn.out <- PONG + " :" + message }
diff --git a/client/commands_test.go b/client/commands_test.go
index c3bb6ee..05650e3 100644
--- a/client/commands_test.go
+++ b/client/commands_test.go
@@ -75,4 +75,10 @@ func TestClientCommands(t *testing.T) {
 
 	c.Oper("user", "pass")
 	s.nc.Expect("OPER user pass")
+
+	c.Ping("woot")
+	s.nc.Expect("PING :woot")
+
+	c.Pong("pwoot")
+	s.nc.Expect("PONG :pwoot")
 }
diff --git a/client/connection.go b/client/connection.go
index dce6c43..e1128a2 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -15,9 +15,10 @@ import (
 // An IRC connection is represented by this struct.
 type Conn struct {
 	// Connection Hostname and Nickname
-	Host    string
-	Me      *state.Nick
-	Network string
+	Host     string
+	Me       *state.Nick
+	Network  string
+	password string
 
 	// Handlers and Commands
 	handlers *hSet
@@ -60,7 +61,7 @@ type Conn struct {
 	Flood bool
 
 	// Internal counters for flood protection
-	badness time.Duration
+	badness  time.Duration
 	lastsent time.Time
 }
 
@@ -164,13 +165,12 @@ func (conn *Conn) Connect(host string, pass ...string) error {
 	}
 	conn.Host = host
 	conn.Connected = true
-	conn.postConnect()
-
 	if len(pass) > 0 {
-		conn.Pass(pass[0])
+		conn.password = pass[0]
+	} else {
+		conn.password = ""
 	}
-	conn.Nick(conn.Me.Nick)
-	conn.User(conn.Me.Ident, conn.Me.Name)
+	conn.postConnect()
 	return nil
 }
 
@@ -188,6 +188,7 @@ func (conn *Conn) postConnect() {
 		go func() { <-conn.cPing }()
 	}
 	go conn.runLoop()
+	conn.dispatch(&Line{Cmd: INIT})
 }
 
 // copied from http.client for great justice
@@ -235,7 +236,7 @@ func (conn *Conn) ping() {
 	for {
 		select {
 		case <-tick.C:
-			conn.Raw(fmt.Sprintf("PING :%d", time.Now().UnixNano()))
+			conn.Ping(fmt.Sprintf("%d", time.Now().UnixNano()))
 		case <-conn.cPing:
 			tick.Stop()
 			return
@@ -305,7 +306,7 @@ func (conn *Conn) shutdown() {
 	// as calling sock.Close() will cause recv() to recieve EOF in readstring()
 	if conn.Connected {
 		logging.Info("irc.shutdown(): Disconnected from server.")
-		conn.dispatch(&Line{Cmd: "disconnected"})
+		conn.dispatch(&Line{Cmd: DISCONNECTED})
 		conn.Connected = false
 		conn.sock.Close()
 		conn.cSend <- true
diff --git a/client/connection_test.go b/client/connection_test.go
index 6386eb3..e4d09ba 100644
--- a/client/connection_test.go
+++ b/client/connection_test.go
@@ -3,8 +3,8 @@ package client
 import (
 	"bufio"
 	"code.google.com/p/gomock/gomock"
-	"github.com/fluffle/golog/logging"
 	"github.com/fluffle/goirc/state"
+	"github.com/fluffle/golog/logging"
 	"strings"
 	"testing"
 	"time"
@@ -33,6 +33,10 @@ func setUp(t *testing.T, start ...bool) (*Conn, *testState) {
 		// Hack to allow tests of send, recv, write etc.
 		// NOTE: the value of the boolean doesn't matter.
 		c.postConnect()
+		// All connections start with NICK/USER expect these.
+		nc.Expect("NICK test")
+		nc.Expect("USER test 12 * :Testing IRC")
+
 		// Sleep 1ms to allow background routines to start.
 		<-time.After(1e6)
 	}
@@ -57,7 +61,7 @@ func TestEOF(t *testing.T) {
 
 	// Set up a handler to detect whether disconnected handlers are called
 	dcon := false
-	c.HandleFunc("disconnected", func (conn *Conn, line *Line) {
+	c.HandleFunc(DISCONNECTED, func(conn *Conn, line *Line) {
 		dcon = true
 	})
 
@@ -356,12 +360,12 @@ func TestRunLoop(t *testing.T) {
 
 	// Set up a handler to detect whether 001 handler is called
 	h001 := false
-	c.HandleFunc("001", func (conn *Conn, line *Line) {
+	c.HandleFunc("001", func(conn *Conn, line *Line) {
 		h001 = true
 	})
 	// Set up a handler to detect whether 002 handler is called
 	h002 := false
-	c.HandleFunc("002", func (conn *Conn, line *Line) {
+	c.HandleFunc("002", func(conn *Conn, line *Line) {
 		h002 = true
 	})
 
@@ -470,7 +474,7 @@ func TestRateLimit(t *testing.T) {
 
 	// We'll be needing this later...
 	abs := func(i time.Duration) time.Duration {
-		if (i < 0) {
+		if i < 0 {
 			return -i
 		}
 		return i
@@ -491,13 +495,13 @@ func TestRateLimit(t *testing.T) {
 	// 2.5 seconds minus the delta between the two ratelimit calls. This should
 	// be minimal but it's guaranteed that it won't be zero. Use 10us as a fuzz.
 	if l := c.rateLimit(60); l != 0 ||
-		abs(c.badness - 2500*time.Millisecond) > 10 * time.Microsecond {
+		abs(c.badness-2500*time.Millisecond) > 10*time.Microsecond {
 		t.Errorf("Rate limit calculating badness incorrectly.")
 	}
 	// At this point, we can tip over the badness scale, with a bit of help.
 	// 720 chars => +8 seconds of badness => 10.5 seconds => ratelimit
-	if l := c.rateLimit(720); l != 8 * time.Second ||
-		abs(c.badness - 10500*time.Millisecond) > 10 * time.Microsecond {
+	if l := c.rateLimit(720); l != 8*time.Second ||
+		abs(c.badness-10500*time.Millisecond) > 10*time.Microsecond {
 		t.Errorf("Rate limit failed to return correct limiting values.")
 		t.Errorf("l=%d, badness=%d", l, c.badness)
 	}
diff --git a/client/dispatch.go b/client/dispatch.go
index f35a10f..dd73865 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -105,7 +105,9 @@ func (hs *hSet) dispatch(conn *Conn, line *Line) {
 	defer hs.RUnlock()
 	ev := strings.ToLower(line.Cmd)
 	list, ok := hs.set[ev]
-	if !ok { return }
+	if !ok {
+		return
+	}
 	for hn := list.start; hn != nil; hn = hn.next {
 		go hn.Handle(conn, line)
 	}
diff --git a/client/dispatch_test.go b/client/dispatch_test.go
index 427c69e..84b9e54 100644
--- a/client/dispatch_test.go
+++ b/client/dispatch_test.go
@@ -83,7 +83,7 @@ func TestHandlerSet(t *testing.T) {
 	if callcount != 0 {
 		t.Errorf("Something incremented call count before we were expecting it.")
 	}
-	hs.dispatch(nil, &Line{Cmd:"One"})
+	hs.dispatch(nil, &Line{Cmd: "One"})
 	<-time.After(time.Millisecond)
 	if callcount != 4 {
 		t.Errorf("Our handler wasn't called four times :-(")
@@ -107,7 +107,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Dispatch should result in 3 additions.
-	hs.dispatch(nil, &Line{Cmd:"One"})
+	hs.dispatch(nil, &Line{Cmd: "One"})
 	<-time.After(time.Millisecond)
 	if callcount != 7 {
 		t.Errorf("Our handler wasn't called three times :-(")
@@ -129,7 +129,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Dispatch should result in 2 additions.
-	hs.dispatch(nil, &Line{Cmd:"One"})
+	hs.dispatch(nil, &Line{Cmd: "One"})
 	<-time.After(time.Millisecond)
 	if callcount != 9 {
 		t.Errorf("Our handler wasn't called two times :-(")
@@ -151,7 +151,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Dispatch should result in 1 addition.
-	hs.dispatch(nil, &Line{Cmd:"One"})
+	hs.dispatch(nil, &Line{Cmd: "One"})
 	<-time.After(time.Millisecond)
 	if callcount != 10 {
 		t.Errorf("Our handler wasn't called once :-(")
@@ -170,7 +170,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Dispatch should result in NO additions.
-	hs.dispatch(nil, &Line{Cmd:"One"})
+	hs.dispatch(nil, &Line{Cmd: "One"})
 	<-time.After(time.Millisecond)
 	if callcount != 10 {
 		t.Errorf("Our handler was called?")
@@ -184,7 +184,7 @@ func TestCommandSet(t *testing.T) {
 	}
 
 	c := &command{
-		fn: func(c *Conn, l *Line) {},
+		fn:   func(c *Conn, l *Line) {},
 		help: "wtf?",
 	}
 
@@ -196,7 +196,7 @@ func TestCommandSet(t *testing.T) {
 	if fail := cs.add("one", c); fail != nil {
 		t.Errorf("Adding a second 'one' command did not fail as expected.")
 	}
-	
+
 	cn2 := cs.add("One Two", c).(*cNode)
 	if _, ok := cs.set["one two"]; !ok || cn2.set != cs || cn2.prefix != "one two" {
 		t.Errorf("Command 'one two' not added to set correctly.")
@@ -208,7 +208,7 @@ func TestCommandSet(t *testing.T) {
 	if c, l := cs.match("one"); c.(*cNode) != cn1 || l != 3 {
 		t.Errorf("Didn't match 'one' when we should have.")
 	}
-	if c, l := cs.match ("one two three"); c.(*cNode) != cn2 || l != 7 {
+	if c, l := cs.match("one two three"); c.(*cNode) != cn2 || l != 7 {
 		t.Errorf("Didn't match 'one two' when we should have.")
 	}
 
@@ -216,14 +216,14 @@ func TestCommandSet(t *testing.T) {
 	if _, ok := cs.set["one two"]; ok || cn2.set != nil {
 		t.Errorf("Command 'one two' not removed correctly.")
 	}
-	if c, l := cs.match ("one two three"); c.(*cNode) != cn1 || l != 3 {
+	if c, l := cs.match("one two three"); c.(*cNode) != cn1 || l != 3 {
 		t.Errorf("Didn't match 'one' when we should have.")
 	}
 	cn1.Remove()
 	if _, ok := cs.set["one"]; ok || cn1.set != nil {
 		t.Errorf("Command 'one' not removed correctly.")
 	}
-	if c, l := cs.match ("one two three"); c != nil || l != 0 {
+	if c, l := cs.match("one two three"); c != nil || l != 0 {
 		t.Errorf("Matched 'one' when we shouldn't have.")
 	}
 }
diff --git a/client/handlers.go b/client/handlers.go
index dcc48f9..5d017be 100644
--- a/client/handlers.go
+++ b/client/handlers.go
@@ -9,11 +9,12 @@ import (
 
 // sets up the internal event handlers to do essential IRC protocol things
 var intHandlers = map[string]HandlerFunc{
+	INIT:  (*Conn).h_init,
 	"001": (*Conn).h_001,
 	"433": (*Conn).h_433,
-	"CTCP": (*Conn).h_CTCP,
-	"NICK": (*Conn).h_NICK,
-	"PING": (*Conn).h_PING,
+	CTCP:  (*Conn).h_CTCP,
+	NICK:  (*Conn).h_NICK,
+	PING:  (*Conn).h_PING,
 }
 
 func (conn *Conn) addIntHandlers() {
@@ -24,15 +25,24 @@ func (conn *Conn) addIntHandlers() {
 	}
 }
 
+// Password/User/Nick broadcast on connection.
+func (conn *Conn) h_init(line *Line) {
+	if conn.password != "" {
+		conn.Pass(conn.password)
+	}
+	conn.Nick(conn.Me.Nick)
+	conn.User(conn.Me.Ident, conn.Me.Name)
+}
+
 // Basic ping/pong handler
 func (conn *Conn) h_PING(line *Line) {
-	conn.Raw("PONG :" + line.Args[0])
+	conn.Pong(line.Args[0])
 }
 
 // Handler to trigger a "CONNECTED" event on receipt of numeric 001
 func (conn *Conn) h_001(line *Line) {
 	// we're connected!
-	conn.dispatch(&Line{Cmd: "connected"})
+	conn.dispatch(&Line{Cmd: CONNECTED})
 	// and we're being given our hostname (from the server's perspective)
 	t := line.Args[len(line.Args)-1]
 	if idx := strings.LastIndex(t, " "); idx != -1 {
@@ -70,10 +80,10 @@ func (conn *Conn) h_433(line *Line) {
 
 // Handle VERSION requests and CTCP PING
 func (conn *Conn) h_CTCP(line *Line) {
-	if line.Args[0] == "VERSION" {
-		conn.CtcpReply(line.Nick, "VERSION", "powered by goirc...")
-	} else if line.Args[0] == "PING" {
-		conn.CtcpReply(line.Nick, "PING", line.Args[2])
+	if line.Args[0] == VERSION {
+		conn.CtcpReply(line.Nick, VERSION, "powered by goirc...")
+	} else if line.Args[0] == PING {
+		conn.CtcpReply(line.Nick, PING, line.Args[2])
 	}
 }
 
@@ -99,7 +109,9 @@ func (conn *Conn) h_PRIVMSG(line *Line) {
 		}
 	}
 	cmd, l := conn.cmdMatch(txt)
-	if cmd == nil { return }
+	if cmd == nil {
+		return
+	}
 	if conn.CommandStripPrefix {
 		txt = strings.TrimSpace(txt[l:])
 	}
diff --git a/client/handlers_test.go b/client/handlers_test.go
index fcedbb2..1389967 100644
--- a/client/handlers_test.go
+++ b/client/handlers_test.go
@@ -27,7 +27,7 @@ func Test001(t *testing.T) {
 	l := parseLine(":irc.server.org 001 test :Welcome to IRC test!ident@somehost.com")
 	// Set up a handler to detect whether connected handler is called from 001
 	hcon := false
-	c.HandleFunc("connected", func (conn *Conn, line *Line) {
+	c.HandleFunc(CONNECTED, func(conn *Conn, line *Line) {
 		hcon = true
 	})
 
@@ -139,11 +139,11 @@ func TestCTCP(t *testing.T) {
 	c.h_CTCP(parseLine(":blah!moo@cows.com PRIVMSG test :\001UNKNOWN ctcp\001"))
 }
 
-func TestPRIVMSG(t *testing.T){
+func TestPRIVMSG(t *testing.T) {
 	c, s := setUp(t)
 	defer s.tearDown()
 
-	f := func (conn *Conn, line *Line) {
+	f := func(conn *Conn, line *Line) {
 		conn.Privmsg(line.Args[0], line.Args[1])
 	}
 	c.CommandFunc("prefix", f, "")
@@ -188,7 +188,6 @@ func TestPRIVMSG(t *testing.T){
 	c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test! prefix bar"))
 	s.nc.ExpectNothing()
 
-
 }
 
 // Test the handler for JOIN messages
@@ -317,7 +316,6 @@ func TestMODE(t *testing.T) {
 		t.Errorf("Channel.ParseModes() not called correctly.")
 	}
 
-
 	// Send a nick mode line, returning Me
 	gomock.InOrder(
 		s.st.EXPECT().GetChannel("test").Return(nil),
diff --git a/client/line.go b/client/line.go
index 706d373..b29a8fe 100644
--- a/client/line.go
+++ b/client/line.go
@@ -62,7 +62,7 @@ func parseLine(s string) *Line {
 	// So, I think CTCP and (in particular) CTCP ACTION are better handled as
 	// separate events as opposed to forcing people to have gargantuan
 	// handlers to cope with the possibilities.
-	if (line.Cmd == "PRIVMSG" || line.Cmd == "NOTICE") &&
+	if (line.Cmd == PRIVMSG || line.Cmd == NOTICE) &&
 		len(line.Args[1]) > 2 &&
 		strings.HasPrefix(line.Args[1], "\001") &&
 		strings.HasSuffix(line.Args[1], "\001") {
@@ -72,16 +72,16 @@ func parseLine(s string) *Line {
 			// Replace the line with the unwrapped CTCP
 			line.Args[1] = t[1]
 		}
-		if c := strings.ToUpper(t[0]); c == "ACTION" && line.Cmd == "PRIVMSG" {
+		if c := strings.ToUpper(t[0]); c == ACTION && line.Cmd == PRIVMSG {
 			// make a CTCP ACTION it's own event a-la PRIVMSG
 			line.Cmd = c
 		} else {
 			// otherwise, dispatch a generic CTCP/CTCPREPLY event that
 			// contains the type of CTCP in line.Args[0]
-			if line.Cmd == "PRIVMSG" {
-				line.Cmd = "CTCP"
+			if line.Cmd == PRIVMSG {
+				line.Cmd = CTCP
 			} else {
-				line.Cmd = "CTCPREPLY"
+				line.Cmd = CTCPREPLY
 			}
 			line.Args = append([]string{c}, line.Args...)
 		}
diff --git a/client/line_test.go b/client/line_test.go
index 6b9af7e..37e43dd 100644
--- a/client/line_test.go
+++ b/client/line_test.go
@@ -7,14 +7,14 @@ import (
 
 func TestCopy(t *testing.T) {
 	l1 := &Line{
-		Nick: "nick",
+		Nick:  "nick",
 		Ident: "ident",
-		Host: "host",
-		Src: "src",
-		Cmd: "cmd",
-		Raw: "raw",
-		Args: []string{"arg", "text"},
-		Time: time.Now(),
+		Host:  "host",
+		Src:   "src",
+		Cmd:   "cmd",
+		Raw:   "raw",
+		Args:  []string{"arg", "text"},
+		Time:  time.Now(),
 	}
 
 	l2 := l1.Copy()
diff --git a/client/state_handlers.go b/client/state_handlers.go
index ab2e60a..ffc9211 100644
--- a/client/state_handlers.go
+++ b/client/state_handlers.go
@@ -9,19 +9,19 @@ import (
 )
 
 var stHandlers = map[string]HandlerFunc{
-	"JOIN": (*Conn).h_JOIN,
-	"KICK": (*Conn).h_KICK,
-	"MODE": (*Conn).h_MODE,
-	"NICK": (*Conn).h_STNICK,
-	"PART": (*Conn).h_PART,
-	"QUIT": (*Conn).h_QUIT,
+	"JOIN":  (*Conn).h_JOIN,
+	"KICK":  (*Conn).h_KICK,
+	"MODE":  (*Conn).h_MODE,
+	"NICK":  (*Conn).h_STNICK,
+	"PART":  (*Conn).h_PART,
+	"QUIT":  (*Conn).h_QUIT,
 	"TOPIC": (*Conn).h_TOPIC,
-	"311": (*Conn).h_311,
-	"324": (*Conn).h_324,
-	"332": (*Conn).h_332,
-	"352": (*Conn).h_352,
-	"353": (*Conn).h_353,
-	"671": (*Conn).h_671,
+	"311":   (*Conn).h_311,
+	"324":   (*Conn).h_324,
+	"332":   (*Conn).h_332,
+	"352":   (*Conn).h_352,
+	"353":   (*Conn).h_353,
+	"671":   (*Conn).h_671,
 }
 
 func (conn *Conn) addSTHandlers() {

From ed85f957b53c71fb8eda74025eb648679779a3c5 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Fri, 15 Feb 2013 19:47:10 -0800
Subject: [PATCH 02/13] Call init in connect so theres no special casing for
 tests.

---
 client/connection.go      | 2 +-
 client/connection_test.go | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/client/connection.go b/client/connection.go
index e1128a2..1cd0ece 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -171,6 +171,7 @@ func (conn *Conn) Connect(host string, pass ...string) error {
 		conn.password = ""
 	}
 	conn.postConnect()
+	conn.dispatch(&Line{Cmd: INIT})
 	return nil
 }
 
@@ -188,7 +189,6 @@ func (conn *Conn) postConnect() {
 		go func() { <-conn.cPing }()
 	}
 	go conn.runLoop()
-	conn.dispatch(&Line{Cmd: INIT})
 }
 
 // copied from http.client for great justice
diff --git a/client/connection_test.go b/client/connection_test.go
index e4d09ba..f03dc4e 100644
--- a/client/connection_test.go
+++ b/client/connection_test.go
@@ -33,9 +33,6 @@ func setUp(t *testing.T, start ...bool) (*Conn, *testState) {
 		// Hack to allow tests of send, recv, write etc.
 		// NOTE: the value of the boolean doesn't matter.
 		c.postConnect()
-		// All connections start with NICK/USER expect these.
-		nc.Expect("NICK test")
-		nc.Expect("USER test 12 * :Testing IRC")
 
 		// Sleep 1ms to allow background routines to start.
 		<-time.After(1e6)

From 18a149335b6c5f187e65a374d18ce69ec2c17d22 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sat, 16 Feb 2013 19:57:54 -0800
Subject: [PATCH 03/13] Add a listener for YouTube and URLs, and spit out the
 Video Name or Title back to the sourc.

---
 client.go       |  3 +++
 client/funcs.go | 71 +++++++++++++++++++++++++++++++++++++++++++++++++
 client/line.go  | 23 ++++++++++++++++
 3 files changed, 97 insertions(+)
 create mode 100644 client/funcs.go

diff --git a/client.go b/client.go
index 0ff9d18..af65da9 100644
--- a/client.go
+++ b/client.go
@@ -26,6 +26,9 @@ func main() {
 	c.HandleFunc(irc.DISCONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
+	c.HandleFunc(irc.PRIVMSG, YouTubeFunc)
+	c.HandleFunc(irc.PRIVMSG, UrlFunc)
+
 	// set up a goroutine to read commands from stdin
 	in := make(chan string, 4)
 	reallyquit := false
diff --git a/client/funcs.go b/client/funcs.go
new file mode 100644
index 0000000..65b4164
--- /dev/null
+++ b/client/funcs.go
@@ -0,0 +1,71 @@
+package client
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"regexp"
+	"strings"
+)
+
+type youTubeVideo struct {
+	Entry struct {
+		Info struct {
+			Title struct {
+				Text string `json:"$t"`
+			} `json:"media$title"`
+			Description struct {
+				Text string `json:"$t"`
+			} `json:"media$description"`
+		} `json:"media$group"`
+		Rating struct {
+			Likes    string `json:"numLikes"`
+			Dislikes string `json:"numDislikes"`
+		} `json:"yt$rating"`
+		Statistics struct {
+			Views string `json:"viewCount"`
+		} `json:"yt$statistics"`
+	} `json:entry`
+}
+
+func UrlFunc(conn *Conn, line *Line) {
+	text := line.Message()
+	if regex, err := regexp.Compile(`(\s|^)(http://|https://)(.*?)(\s|$)`); err == nil {
+		url := strings.TrimSpace(regex.FindString(text))
+		if url != "" {
+			if resp, err := http.Get(url); err == nil {
+				if strings.HasPrefix(resp.Header.Get("Content-Type"), "text/html") {
+					defer resp.Body.Close()
+					if content, err := ioutil.ReadAll(resp.Body); err == nil {
+						if regex, err := regexp.Compile(`<title>(.*?)</title>`); err == nil {
+							if regex.Match([]byte(content)) {
+								conn.Privmsg(line.Target(), strings.TrimSpace(regex.FindStringSubmatch(string(content))[1]))
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func YouTubeFunc(conn *Conn, line *Line) {
+	text := line.Message()
+	if regex, err := regexp.Compile(`(\s|^)(http://|https://)?(www.)?(youtube.com/watch\?v=|youtu.be/)(.*?)(\s|$|\&|#)`); err == nil {
+		if regex.Match([]byte(text)) {
+			matches := regex.FindStringSubmatch(text)
+			id := matches[len(matches)-2]
+			url := fmt.Sprintf("https://gdata.youtube.com/feeds/api/videos/%s?v=2&alt=json", id)
+			if resp, err := http.Get(url); err == nil {
+				defer resp.Body.Close()
+				if contents, err := ioutil.ReadAll(resp.Body); err == nil {
+					var data youTubeVideo
+					if err := json.Unmarshal(contents, &data); err == nil {
+						conn.Privmsg(line.Target(), fmt.Sprintf("%s - %s views (%s likes, %s dislikes)", data.Entry.Info.Title.Text, data.Entry.Statistics.Views, data.Entry.Rating.Likes, data.Entry.Rating.Dislikes))
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/client/line.go b/client/line.go
index b29a8fe..2cb53e1 100644
--- a/client/line.go
+++ b/client/line.go
@@ -88,3 +88,26 @@ func parseLine(s string) *Line {
 	}
 	return line
 }
+
+// Return the contents of the message portion of a line.
+// This only really makes sense for messages with a :message portion, but there
+// are a lot of them.
+func (line *Line) Message() string {
+	if len(line.Args) > 0 {
+		return line.Args[len(line.Args)-1]
+	}
+	return ""
+}
+
+// Return the target of the line. This only really makes sense for PRIVMSG.
+// If the line was broadcast from a channel, the target will be that channel.
+// If the line was broadcast by a user, the target will be that user.
+func (line *Line) Target() string {
+	if line.Cmd == PRIVMSG {
+		if !strings.HasPrefix(line.Args[0], "#") {
+			return line.Nick
+		}
+		return line.Args[0]
+	}
+	return ""
+}

From 89c23a778709f48acd97156158e5dc388faaef23 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sat, 16 Feb 2013 23:50:42 -0800
Subject: [PATCH 04/13] Add support for complex regex commands.

Refactor commands so they are just handlers.
Add commands that listen for YouTube/Webpage mentions and print information (Video Info/Title).
Add simple command examples in client.go
TODO: Use a better data store for the commands, perhaps a linked list like handlers.
---
 client.go            |  35 ++++++++--
 client/connection.go |   7 +-
 client/dispatch.go   | 161 ++++++++++++++++++++++++++-----------------
 client/funcs.go      |   8 ++-
 client/handlers.go   |  44 +++---------
 5 files changed, 143 insertions(+), 112 deletions(-)

diff --git a/client.go b/client.go
index af65da9..8575564 100644
--- a/client.go
+++ b/client.go
@@ -5,18 +5,23 @@ import (
 	"flag"
 	"fmt"
 	irc "github.com/fluffle/goirc/client"
+	"math/rand"
 	"os"
+	"strconv"
 	"strings"
 )
 
-var host *string = flag.String("host", "irc.freenode.net", "IRC server")
+var host *string = flag.String("host", "irc.synirc.net", "IRC server")
 var channel *string = flag.String("channel", "#go-nuts", "IRC channel")
+var nick *string = flag.String("nick", "Septapus", "Nick")
+var ident *string = flag.String("ident", "Septapus", "Ident")
+var name *string = flag.String("name", "Septapus v9", "Name")
 
 func main() {
 	flag.Parse()
 
 	// create new IRC connection
-	c := irc.Client("GoTest", "gotest")
+	c := irc.Client(*nick, *ident, *name)
 	c.EnableStateTracking()
 	c.HandleFunc(irc.CONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { conn.Join(*channel) })
@@ -26,8 +31,27 @@ func main() {
 	c.HandleFunc(irc.DISCONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
-	c.HandleFunc(irc.PRIVMSG, YouTubeFunc)
-	c.HandleFunc(irc.PRIVMSG, UrlFunc)
+	// Set up some simple commands, !bark and !roll.
+	c.SimpleCommandFunc("bark", func(conn *irc.Conn, line *irc.Line) { conn.Privmsg(line.Target(), "Woof Woof") })
+	c.SimpleCommandHelpFunc("roll", `Rolls a d6, "roll <n>" to roll n dice at once.`, func(conn *irc.Conn, line *irc.Line) {
+		count := 1
+		fields := strings.Fields(line.Message())
+		if len(fields) > 1 {
+			var err error
+			if count, err = strconv.Atoi(fields[len(fields)-1]); err != nil {
+				count = 1
+			}
+		}
+		total := 0
+		for i := 0; i < count; i++ {
+			total += rand.Intn(6) + 1
+		}
+		conn.Privmsg(line.Target(), fmt.Sprintf("%d", total))
+	})
+
+	// Set up some commands that are triggered by a regex in a message.
+	c.CommandFunc(irc.YouTubeRegex, irc.YouTubeFunc, 10)
+	c.CommandFunc(irc.UrlRegex, irc.UrlFunc, 0)
 
 	// set up a goroutine to read commands from stdin
 	in := make(chan string, 4)
@@ -87,10 +111,9 @@ func main() {
 	for !reallyquit {
 		// connect to server
 		if err := c.Connect(*host); err != nil {
-			fmt.Printf("Connection error: %s\n", err)
+			fmt.Printf("Error %v", err)
 			return
 		}
-
 		// wait on quit channel
 		<-quit
 	}
diff --git a/client/connection.go b/client/connection.go
index 1cd0ece..b9ea58c 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -22,7 +22,7 @@ type Conn struct {
 
 	// Handlers and Commands
 	handlers *hSet
-	commands *cSet
+	commands *commandSet
 
 	// State tracker for nicks and channels
 	ST         state.StateTracker
@@ -54,9 +54,6 @@ type Conn struct {
 	// Client->server ping frequency, in seconds. Defaults to 3m.
 	PingFreq time.Duration
 
-	// Controls what is stripped from line.Args[1] for Commands
-	CommandStripNick, CommandStripPrefix bool
-
 	// Set this to true to disable flood protection and false to re-enable
 	Flood bool
 
@@ -85,7 +82,7 @@ func Client(nick string, args ...string) *Conn {
 		cLoop:      make(chan bool),
 		cPing:      make(chan bool),
 		handlers:   handlerSet(),
-		commands:   commandSet(),
+		commands:   newCommandSet(),
 		stRemovers: make([]Remover, 0, len(stHandlers)),
 		PingFreq:   3 * time.Minute,
 		NewNick:    func(s string) string { return s + "_" },
diff --git a/client/dispatch.go b/client/dispatch.go
index dd73865..816c126 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -1,7 +1,10 @@
 package client
 
 import (
+	"fmt"
 	"github.com/fluffle/golog/logging"
+	"math"
+	"regexp"
 	"strings"
 	"sync"
 )
@@ -16,6 +19,12 @@ type Remover interface {
 	Remove()
 }
 
+type RemoverFunc func()
+
+func (r RemoverFunc) Remove() {
+	r()
+}
+
 type HandlerFunc func(*Conn, *Line)
 
 func (hf HandlerFunc) Handle(conn *Conn, line *Line) {
@@ -113,87 +122,76 @@ func (hs *hSet) dispatch(conn *Conn, line *Line) {
 	}
 }
 
-// An IRC command looks like this:
-type Command interface {
-	Execute(*Conn, *Line)
-	Help() string
-}
-
 type command struct {
-	fn   HandlerFunc
-	help string
+	handler  Handler
+	set      *commandSet
+	regex    string
+	priority int
 }
 
-func (c *command) Execute(conn *Conn, line *Line) {
-	c.fn(conn, line)
+func (c *command) Handle(conn *Conn, line *Line) {
+	c.handler.Handle(conn, line)
 }
 
-func (c *command) Help() string {
-	return c.help
+func (c *command) Remove() {
+	c.set.remove(c)
 }
 
-type cNode struct {
-	cmd    Command
-	set    *cSet
-	prefix string
-}
-
-func (cn *cNode) Execute(conn *Conn, line *Line) {
-	cn.cmd.Execute(conn, line)
-}
-
-func (cn *cNode) Help() string {
-	return cn.cmd.Help()
-}
-
-func (cn *cNode) Remove() {
-	cn.set.remove(cn)
-}
-
-type cSet struct {
-	set map[string]*cNode
+type commandSet struct {
+	set []*command
 	sync.RWMutex
 }
 
-func commandSet() *cSet {
-	return &cSet{set: make(map[string]*cNode)}
+func newCommandSet() *commandSet {
+	return &commandSet{}
 }
 
-func (cs *cSet) add(pf string, c Command) Remover {
+func (cs *commandSet) add(regex string, handler Handler, priority int) Remover {
 	cs.Lock()
 	defer cs.Unlock()
-	pf = strings.ToLower(pf)
-	if _, ok := cs.set[pf]; ok {
-		logging.Error("Command prefix '%s' already registered.", pf)
-		return nil
+	c := &command{
+		handler:  handler,
+		set:      cs,
+		regex:    regex,
+		priority: priority,
 	}
-	cn := &cNode{
-		cmd:    c,
-		set:    cs,
-		prefix: pf,
+	// Check for exact regex matches. This will filter out any repeated SimpleCommands.
+	for _, c := range cs.set {
+		if c.regex == regex {
+			logging.Error("Command prefix '%s' already registered.", regex)
+			return nil
+		}
 	}
-	cs.set[pf] = cn
-	return cn
+	cs.set = append(cs.set, c)
+	return c
 }
 
-func (cs *cSet) remove(cn *cNode) {
+func (cs *commandSet) remove(c *command) {
 	cs.Lock()
 	defer cs.Unlock()
-	delete(cs.set, cn.prefix)
-	cn.set = nil
+	for index, value := range cs.set {
+		if value == c {
+			copy(cs.set[index:], cs.set[index+1:])
+			cs.set = cs.set[:len(cs.set)-1]
+			c.set = nil
+			return
+		}
+	}
 }
 
-func (cs *cSet) match(txt string) (final Command, prefixlen int) {
+// Matches the command with the highest priority.
+func (cs *commandSet) match(txt string) (handler Handler) {
 	cs.RLock()
 	defer cs.RUnlock()
-	txt = strings.ToLower(txt)
-	for prefix, cmd := range cs.set {
-		if !strings.HasPrefix(txt, prefix) {
-			continue
-		}
-		if final == nil || len(prefix) > prefixlen {
-			prefixlen = len(prefix)
-			final = cmd
+	maxPriority := math.MinInt32
+	for _, c := range cs.set {
+		if c.priority > maxPriority {
+			if regex, error := regexp.Compile(c.regex); error == nil {
+				if regex.MatchString(txt) {
+					maxPriority = c.priority
+					handler = c.handler
+				}
+			}
 		}
 	}
 	return
@@ -213,18 +211,55 @@ func (conn *Conn) HandleFunc(name string, hf HandlerFunc) Remover {
 	return conn.Handle(name, hf)
 }
 
-func (conn *Conn) Command(prefix string, c Command) Remover {
-	return conn.commands.add(prefix, c)
+func (conn *Conn) Command(regex string, handler Handler, priority int) Remover {
+	return conn.commands.add(regex, handler, priority)
 }
 
-func (conn *Conn) CommandFunc(prefix string, hf HandlerFunc, help string) Remover {
-	return conn.Command(prefix, &command{hf, help})
+func (conn *Conn) CommandFunc(regex string, handlerFunc HandlerFunc, priority int) Remover {
+	return conn.Command(regex, handlerFunc, priority)
+}
+
+var SimpleCommandRegex string = `^!%v(\s|$)`
+
+// Simple commands are commands that are triggered from a simple prefix
+// SimpleCommand("roll" handler)
+// !roll
+// Because simple commands are simple, they get the highest priority.
+func (conn *Conn) SimpleCommand(prefix string, handler Handler) Remover {
+	return conn.Command(fmt.Sprintf(SimpleCommandRegex, strings.ToLower(prefix)), handler, math.MaxInt32)
+}
+
+func (conn *Conn) SimpleCommandFunc(prefix string, handlerFunc HandlerFunc) Remover {
+	return conn.SimpleCommand(prefix, handlerFunc)
+}
+
+// This will also register a help command to go along with the simple command itself.
+// eg. SimpleCommandHelp("bark", "Bot will bark", handler) will make the following commands:
+// !bark
+// !help bark
+func (conn *Conn) SimpleCommandHelp(prefix string, help string, handler Handler) Remover {
+	commandCommand := conn.SimpleCommand(prefix, handler)
+	helpCommand := conn.SimpleCommandFunc(fmt.Sprintf("help %v", prefix), HandlerFunc(func(conn *Conn, line *Line) {
+		conn.Privmsg(line.Target(), help)
+	}))
+	return RemoverFunc(func() {
+		commandCommand.Remove()
+		helpCommand.Remove()
+	})
+}
+
+func (conn *Conn) SimpleCommandHelpFunc(prefix string, help string, handlerFunc HandlerFunc) Remover {
+	return conn.SimpleCommandHelp(prefix, help, handlerFunc)
 }
 
 func (conn *Conn) dispatch(line *Line) {
 	conn.handlers.dispatch(conn, line)
 }
 
-func (conn *Conn) cmdMatch(txt string) (Command, int) {
-	return conn.commands.match(txt)
+func (conn *Conn) command(line *Line) {
+	command := conn.commands.match(strings.ToLower(line.Message()))
+	if command != nil {
+		command.Handle(conn, line)
+	}
+
 }
diff --git a/client/funcs.go b/client/funcs.go
index 65b4164..0e8cec9 100644
--- a/client/funcs.go
+++ b/client/funcs.go
@@ -29,9 +29,11 @@ type youTubeVideo struct {
 	} `json:entry`
 }
 
+var UrlRegex string = `(\s|^)(http://|https://)(.*?)(\s|$)`
+
 func UrlFunc(conn *Conn, line *Line) {
 	text := line.Message()
-	if regex, err := regexp.Compile(`(\s|^)(http://|https://)(.*?)(\s|$)`); err == nil {
+	if regex, err := regexp.Compile(UrlRegex); err == nil {
 		url := strings.TrimSpace(regex.FindString(text))
 		if url != "" {
 			if resp, err := http.Get(url); err == nil {
@@ -50,9 +52,11 @@ func UrlFunc(conn *Conn, line *Line) {
 	}
 }
 
+var YouTubeRegex string = `(\s|^)(http://|https://)?(www.)?(youtube.com/watch\?v=|youtu.be/)(.*?)(\s|$|\&|#)`
+
 func YouTubeFunc(conn *Conn, line *Line) {
 	text := line.Message()
-	if regex, err := regexp.Compile(`(\s|^)(http://|https://)?(www.)?(youtube.com/watch\?v=|youtu.be/)(.*?)(\s|$|\&|#)`); err == nil {
+	if regex, err := regexp.Compile(YouTubeRegex); err == nil {
 		if regex.Match([]byte(text)) {
 			matches := regex.FindStringSubmatch(text)
 			id := matches[len(matches)-2]
diff --git a/client/handlers.go b/client/handlers.go
index 5d017be..f5ded17 100644
--- a/client/handlers.go
+++ b/client/handlers.go
@@ -9,12 +9,13 @@ import (
 
 // sets up the internal event handlers to do essential IRC protocol things
 var intHandlers = map[string]HandlerFunc{
-	INIT:  (*Conn).h_init,
-	"001": (*Conn).h_001,
-	"433": (*Conn).h_433,
-	CTCP:  (*Conn).h_CTCP,
-	NICK:  (*Conn).h_NICK,
-	PING:  (*Conn).h_PING,
+	INIT:    (*Conn).h_init,
+	"001":   (*Conn).h_001,
+	"433":   (*Conn).h_433,
+	CTCP:    (*Conn).h_CTCP,
+	NICK:    (*Conn).h_NICK,
+	PING:    (*Conn).h_PING,
+	PRIVMSG: (*Conn).h_PRIVMSG,
 }
 
 func (conn *Conn) addIntHandlers() {
@@ -96,34 +97,5 @@ func (conn *Conn) h_NICK(line *Line) {
 
 // Handle PRIVMSGs that trigger Commands
 func (conn *Conn) h_PRIVMSG(line *Line) {
-	txt := line.Args[1]
-	if conn.CommandStripNick && strings.HasPrefix(txt, conn.Me.Nick) {
-		// Look for '^${nick}[:;>,-]? '
-		l := len(conn.Me.Nick)
-		switch txt[l] {
-		case ':', ';', '>', ',', '-':
-			l++
-		}
-		if txt[l] == ' ' {
-			txt = strings.TrimSpace(txt[l:])
-		}
-	}
-	cmd, l := conn.cmdMatch(txt)
-	if cmd == nil {
-		return
-	}
-	if conn.CommandStripPrefix {
-		txt = strings.TrimSpace(txt[l:])
-	}
-	if txt != line.Args[1] {
-		line = line.Copy()
-		line.Args[1] = txt
-	}
-	cmd.Execute(conn, line)
-}
-
-func (conn *Conn) c_HELP(line *Line) {
-	if cmd, _ := conn.cmdMatch(line.Args[1]); cmd != nil {
-		conn.Privmsg(line.Args[0], cmd.Help())
-	}
+	conn.command(line)
 }

From e8eba538287f1cd057b5c9026c304c8b304c058e Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 00:09:16 -0800
Subject: [PATCH 05/13] Added more documentation, commands are a list now, not
 a set :)

---
 client.go            |  4 +++
 client/connection.go |  4 +--
 client/dispatch.go   | 60 ++++++++++++++++++++++----------------------
 3 files changed, 36 insertions(+), 32 deletions(-)

diff --git a/client.go b/client.go
index 8575564..74baaca 100644
--- a/client.go
+++ b/client.go
@@ -32,6 +32,7 @@ func main() {
 		func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
 	// Set up some simple commands, !bark and !roll.
+	// The !roll command will also get the  "!help roll" command also.
 	c.SimpleCommandFunc("bark", func(conn *irc.Conn, line *irc.Line) { conn.Privmsg(line.Target(), "Woof Woof") })
 	c.SimpleCommandHelpFunc("roll", `Rolls a d6, "roll <n>" to roll n dice at once.`, func(conn *irc.Conn, line *irc.Line) {
 		count := 1
@@ -50,6 +51,9 @@ func main() {
 	})
 
 	// Set up some commands that are triggered by a regex in a message.
+	// It is important to see that UrlRegex could actually respond to some
+	// of the Url's that YouTubeRegex listens to, because of this we put the
+	// YouTube command at a higher priority, this way it will take precedence.
 	c.CommandFunc(irc.YouTubeRegex, irc.YouTubeFunc, 10)
 	c.CommandFunc(irc.UrlRegex, irc.UrlFunc, 0)
 
diff --git a/client/connection.go b/client/connection.go
index b9ea58c..3647ed0 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -22,7 +22,7 @@ type Conn struct {
 
 	// Handlers and Commands
 	handlers *hSet
-	commands *commandSet
+	commands *commandList
 
 	// State tracker for nicks and channels
 	ST         state.StateTracker
@@ -82,7 +82,7 @@ func Client(nick string, args ...string) *Conn {
 		cLoop:      make(chan bool),
 		cPing:      make(chan bool),
 		handlers:   handlerSet(),
-		commands:   newCommandSet(),
+		commands:   newCommandList(),
 		stRemovers: make([]Remover, 0, len(stHandlers)),
 		PingFreq:   3 * time.Minute,
 		NewNick:    func(s string) string { return s + "_" },
diff --git a/client/dispatch.go b/client/dispatch.go
index 816c126..a501e14 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -14,6 +14,12 @@ type Handler interface {
 	Handle(*Conn, *Line)
 }
 
+type HandlerFunc func(*Conn, *Line)
+
+func (hf HandlerFunc) Handle(conn *Conn, line *Line) {
+	hf(conn, line)
+}
+
 // And when they've been added to the client they are removable.
 type Remover interface {
 	Remove()
@@ -25,12 +31,6 @@ func (r RemoverFunc) Remove() {
 	r()
 }
 
-type HandlerFunc func(*Conn, *Line)
-
-func (hf HandlerFunc) Handle(conn *Conn, line *Line) {
-	hf(conn, line)
-}
-
 type hList struct {
 	start, end *hNode
 }
@@ -124,7 +124,7 @@ func (hs *hSet) dispatch(conn *Conn, line *Line) {
 
 type command struct {
 	handler  Handler
-	set      *commandSet
+	set      *commandList
 	regex    string
 	priority int
 }
@@ -137,42 +137,42 @@ func (c *command) Remove() {
 	c.set.remove(c)
 }
 
-type commandSet struct {
+type commandList struct {
 	set []*command
 	sync.RWMutex
 }
 
-func newCommandSet() *commandSet {
-	return &commandSet{}
+func newCommandList() *commandList {
+	return &commandList{}
 }
 
-func (cs *commandSet) add(regex string, handler Handler, priority int) Remover {
-	cs.Lock()
-	defer cs.Unlock()
+func (cl *commandList) add(regex string, handler Handler, priority int) Remover {
+	cl.Lock()
+	defer cl.Unlock()
 	c := &command{
 		handler:  handler,
-		set:      cs,
+		set:      cl,
 		regex:    regex,
 		priority: priority,
 	}
 	// Check for exact regex matches. This will filter out any repeated SimpleCommands.
-	for _, c := range cs.set {
+	for _, c := range cl.set {
 		if c.regex == regex {
 			logging.Error("Command prefix '%s' already registered.", regex)
 			return nil
 		}
 	}
-	cs.set = append(cs.set, c)
+	cl.set = append(cl.set, c)
 	return c
 }
 
-func (cs *commandSet) remove(c *command) {
-	cs.Lock()
-	defer cs.Unlock()
-	for index, value := range cs.set {
+func (cl *commandList) remove(c *command) {
+	cl.Lock()
+	defer cl.Unlock()
+	for index, value := range cl.set {
 		if value == c {
-			copy(cs.set[index:], cs.set[index+1:])
-			cs.set = cs.set[:len(cs.set)-1]
+			copy(cl.set[index:], cl.set[index+1:])
+			cl.set = cl.set[:len(cl.set)-1]
 			c.set = nil
 			return
 		}
@@ -180,11 +180,11 @@ func (cs *commandSet) remove(c *command) {
 }
 
 // Matches the command with the highest priority.
-func (cs *commandSet) match(txt string) (handler Handler) {
-	cs.RLock()
-	defer cs.RUnlock()
+func (cl *commandList) match(txt string) (handler Handler) {
+	cl.RLock()
+	defer cl.RUnlock()
 	maxPriority := math.MinInt32
-	for _, c := range cs.set {
+	for _, c := range cl.set {
 		if c.priority > maxPriority {
 			if regex, error := regexp.Compile(c.regex); error == nil {
 				if regex.MatchString(txt) {
@@ -203,12 +203,12 @@ func (cs *commandSet) match(txt string) (handler Handler) {
 // "PRIVMSG", "JOIN", etc. but all the numeric replies are left as ascii
 // strings of digits like "332" (mainly because I really didn't feel like
 // putting massive constant tables in).
-func (conn *Conn) Handle(name string, h Handler) Remover {
-	return conn.handlers.add(name, h)
+func (conn *Conn) Handle(name string, handler Handler) Remover {
+	return conn.handlers.add(name, handler)
 }
 
-func (conn *Conn) HandleFunc(name string, hf HandlerFunc) Remover {
-	return conn.Handle(name, hf)
+func (conn *Conn) HandleFunc(name string, handlerFunc HandlerFunc) Remover {
+	return conn.Handle(name, handlerFunc)
 }
 
 func (conn *Conn) Command(regex string, handler Handler, priority int) Remover {

From 8007846d51174dcc381e3bf8b18ee2d0ccdfd406 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 10:15:10 -0800
Subject: [PATCH 06/13] Run commands as a goroutine

---
 client/dispatch.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/dispatch.go b/client/dispatch.go
index a501e14..c641abc 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -259,7 +259,7 @@ func (conn *Conn) dispatch(line *Line) {
 func (conn *Conn) command(line *Line) {
 	command := conn.commands.match(strings.ToLower(line.Message()))
 	if command != nil {
-		command.Handle(conn, line)
+		go command.Handle(conn, line)
 	}
 
 }

From e4da830c55a6bcab840c7693c43679e7318ffb53 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 18:40:58 -0800
Subject: [PATCH 07/13] Handlers/Commands now use the container/list.

Re introduced strip nick and strip prefix for SimpleCommands
Fixed tests.
---
 client/connection.go    |   7 +-
 client/dispatch.go      | 164 ++++++++++++++++------------------------
 client/dispatch_test.go | 145 ++++++++++-------------------------
 client/handlers.go      |  20 ++++-
 client/handlers_test.go |   6 +-
 5 files changed, 134 insertions(+), 208 deletions(-)

diff --git a/client/connection.go b/client/connection.go
index 3647ed0..92681d6 100644
--- a/client/connection.go
+++ b/client/connection.go
@@ -21,7 +21,7 @@ type Conn struct {
 	password string
 
 	// Handlers and Commands
-	handlers *hSet
+	handlers *handlerSet
 	commands *commandList
 
 	// State tracker for nicks and channels
@@ -54,6 +54,9 @@ type Conn struct {
 	// Client->server ping frequency, in seconds. Defaults to 3m.
 	PingFreq time.Duration
 
+	// Controls what is stripped from line.Args[1] for Commands
+	CommandStripNick, SimpleCommandStripPrefix bool
+
 	// Set this to true to disable flood protection and false to re-enable
 	Flood bool
 
@@ -81,7 +84,7 @@ func Client(nick string, args ...string) *Conn {
 		cSend:      make(chan bool),
 		cLoop:      make(chan bool),
 		cPing:      make(chan bool),
-		handlers:   handlerSet(),
+		handlers:   newHandlerSet(),
 		commands:   newCommandList(),
 		stRemovers: make([]Remover, 0, len(stHandlers)),
 		PingFreq:   3 * time.Minute,
diff --git a/client/dispatch.go b/client/dispatch.go
index a501e14..3369cd4 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -1,6 +1,7 @@
 package client
 
 import (
+	"container/list"
 	"fmt"
 	"github.com/fluffle/golog/logging"
 	"math"
@@ -31,163 +32,119 @@ func (r RemoverFunc) Remove() {
 	r()
 }
 
-type hList struct {
-	start, end *hNode
+type handlerElement struct {
+	event   string
+	handler Handler
 }
 
-type hNode struct {
-	next, prev *hNode
-	set        *hSet
-	event      string
-	handler    Handler
-}
-
-func (hn *hNode) Handle(conn *Conn, line *Line) {
-	hn.handler.Handle(conn, line)
-}
-
-func (hn *hNode) Remove() {
-	hn.set.remove(hn)
-}
-
-type hSet struct {
-	set map[string]*hList
+type handlerSet struct {
+	set map[string]*list.List
 	sync.RWMutex
 }
 
-func handlerSet() *hSet {
-	return &hSet{set: make(map[string]*hList)}
+func newHandlerSet() *handlerSet {
+	return &handlerSet{set: make(map[string]*list.List)}
 }
 
-func (hs *hSet) add(ev string, h Handler) Remover {
+func (hs *handlerSet) add(event string, handler Handler) Remover {
 	hs.Lock()
 	defer hs.Unlock()
-	ev = strings.ToLower(ev)
-	l, ok := hs.set[ev]
+	event = strings.ToLower(event)
+	l, ok := hs.set[event]
 	if !ok {
-		l = &hList{}
+		l = list.New()
+		hs.set[event] = l
 	}
-	hn := &hNode{
-		set:     hs,
-		event:   ev,
-		handler: h,
-	}
-	if !ok {
-		l.start = hn
-	} else {
-		hn.prev = l.end
-		l.end.next = hn
-	}
-	l.end = hn
-	hs.set[ev] = l
-	return hn
+	element := l.PushBack(&handlerElement{event, handler})
+	return RemoverFunc(func() {
+		hs.remove(element)
+	})
 }
 
-func (hs *hSet) remove(hn *hNode) {
+func (hs *handlerSet) remove(element *list.Element) {
 	hs.Lock()
 	defer hs.Unlock()
-	l, ok := hs.set[hn.event]
+	h := element.Value.(*handlerElement)
+	l, ok := hs.set[h.event]
 	if !ok {
-		logging.Error("Removing node for unknown event '%s'", hn.event)
+		logging.Error("Removing node for unknown event '%s'", h.event)
 		return
 	}
-	if hn.next == nil {
-		l.end = hn.prev
-	} else {
-		hn.next.prev = hn.prev
-	}
-	if hn.prev == nil {
-		l.start = hn.next
-	} else {
-		hn.prev.next = hn.next
-	}
-	hn.next = nil
-	hn.prev = nil
-	hn.set = nil
-	if l.start == nil || l.end == nil {
-		delete(hs.set, hn.event)
+	l.Remove(element)
+	if l.Len() == 0 {
+		delete(hs.set, h.event)
 	}
 }
 
-func (hs *hSet) dispatch(conn *Conn, line *Line) {
+func (hs *handlerSet) dispatch(conn *Conn, line *Line) {
 	hs.RLock()
 	defer hs.RUnlock()
-	ev := strings.ToLower(line.Cmd)
-	list, ok := hs.set[ev]
+	event := strings.ToLower(line.Cmd)
+	l, ok := hs.set[event]
 	if !ok {
 		return
 	}
-	for hn := list.start; hn != nil; hn = hn.next {
-		go hn.Handle(conn, line)
+
+	for e := l.Front(); e != nil; e = e.Next() {
+		h := e.Value.(*handlerElement)
+		go h.handler.Handle(conn, line)
 	}
 }
 
-type command struct {
-	handler  Handler
-	set      *commandList
+type commandElement struct {
 	regex    string
+	handler  Handler
 	priority int
 }
 
-func (c *command) Handle(conn *Conn, line *Line) {
-	c.handler.Handle(conn, line)
-}
-
-func (c *command) Remove() {
-	c.set.remove(c)
-}
-
 type commandList struct {
-	set []*command
+	list *list.List
 	sync.RWMutex
 }
 
 func newCommandList() *commandList {
-	return &commandList{}
+	return &commandList{list: list.New()}
 }
 
 func (cl *commandList) add(regex string, handler Handler, priority int) Remover {
 	cl.Lock()
 	defer cl.Unlock()
-	c := &command{
-		handler:  handler,
-		set:      cl,
+	c := &commandElement{
 		regex:    regex,
+		handler:  handler,
 		priority: priority,
 	}
 	// Check for exact regex matches. This will filter out any repeated SimpleCommands.
-	for _, c := range cl.set {
+	for e := cl.list.Front(); e != nil; e = e.Next() {
+		c := e.Value.(*commandElement)
 		if c.regex == regex {
 			logging.Error("Command prefix '%s' already registered.", regex)
 			return nil
 		}
 	}
-	cl.set = append(cl.set, c)
-	return c
+	element := cl.list.PushBack(c)
+	return RemoverFunc(func() {
+		cl.remove(element)
+	})
 }
 
-func (cl *commandList) remove(c *command) {
+func (cl *commandList) remove(element *list.Element) {
 	cl.Lock()
 	defer cl.Unlock()
-	for index, value := range cl.set {
-		if value == c {
-			copy(cl.set[index:], cl.set[index+1:])
-			cl.set = cl.set[:len(cl.set)-1]
-			c.set = nil
-			return
-		}
-	}
+	cl.list.Remove(element)
 }
 
 // Matches the command with the highest priority.
-func (cl *commandList) match(txt string) (handler Handler) {
+func (cl *commandList) match(text string) (handler Handler) {
 	cl.RLock()
 	defer cl.RUnlock()
 	maxPriority := math.MinInt32
-	for _, c := range cl.set {
+	text = strings.ToLower(text)
+	for e := cl.list.Front(); e != nil; e = e.Next() {
+		c := e.Value.(*commandElement)
 		if c.priority > maxPriority {
 			if regex, error := regexp.Compile(c.regex); error == nil {
-				if regex.MatchString(txt) {
+				if regex.MatchString(text) {
 					maxPriority = c.priority
 					handler = c.handler
 				}
@@ -226,7 +183,18 @@ var SimpleCommandRegex string = `^!%v(\s|$)`
 // !roll
 // Because simple commands are simple, they get the highest priority.
 func (conn *Conn) SimpleCommand(prefix string, handler Handler) Remover {
-	return conn.Command(fmt.Sprintf(SimpleCommandRegex, strings.ToLower(prefix)), handler, math.MaxInt32)
+	stripHandler := func(conn *Conn, line *Line) {
+		text := line.Message()
+		if conn.SimpleCommandStripPrefix {
+			text = strings.TrimSpace(text[len(prefix):])
+		}
+		if text != line.Message() {
+			line = line.Copy()
+			line.Args[1] = text
+		}
+		handler.Handle(conn, line)
+	}
+	return conn.Command(fmt.Sprintf(SimpleCommandRegex, strings.ToLower(prefix)), HandlerFunc(stripHandler), math.MaxInt32)
 }
 
 func (conn *Conn) SimpleCommandFunc(prefix string, handlerFunc HandlerFunc) Remover {
@@ -256,10 +224,6 @@ func (conn *Conn) dispatch(line *Line) {
 	conn.handlers.dispatch(conn, line)
 }
 
-func (conn *Conn) command(line *Line) {
-	command := conn.commands.match(strings.ToLower(line.Message()))
-	if command != nil {
-		command.Handle(conn, line)
-	}
-
+func (conn *Conn) command(line *Line) Handler {
+	return conn.commands.match(line.Message())
 }
diff --git a/client/dispatch_test.go b/client/dispatch_test.go
index 84b9e54..1e3caca 100644
--- a/client/dispatch_test.go
+++ b/client/dispatch_test.go
@@ -6,7 +6,7 @@ import (
 )
 
 func TestHandlerSet(t *testing.T) {
-	hs := handlerSet()
+	hs := newHandlerSet()
 	if len(hs.set) != 0 {
 		t.Errorf("New set contains things!")
 	}
@@ -17,66 +17,40 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Add one
-	hn1 := hs.add("ONE", HandlerFunc(f)).(*hNode)
+	hn1 := hs.add("ONE", HandlerFunc(f))
 	hl, ok := hs.set["one"]
 	if len(hs.set) != 1 || !ok {
 		t.Errorf("Set doesn't contain 'one' list after add().")
 	}
-	if hn1.set != hs || hn1.event != "one" || hn1.prev != nil || hn1.next != nil {
-		t.Errorf("First node for 'one' not created correctly")
-	}
-	if hl.start != hn1 || hl.end != hn1 {
-		t.Errorf("Node not added to empty 'one' list correctly.")
+	if hl.Len() != 1 {
+		t.Errorf("List doesn't contain 'one' after add().")
 	}
 
 	// Add another one...
-	hn2 := hs.add("one", HandlerFunc(f)).(*hNode)
+	hn2 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
-	if hn2.set != hs || hn2.event != "one" {
-		t.Errorf("Second node for 'one' not created correctly")
-	}
-	if hn1.prev != nil || hn1.next != hn2 || hn2.prev != hn1 || hn2.next != nil {
-		t.Errorf("Nodes for 'one' not linked correctly.")
-	}
-	if hl.start != hn1 || hl.end != hn2 {
-		t.Errorf("Node not appended to 'one' list correctly.")
+	if hl.Len() != 2 {
+		t.Errorf("List doesn't contain second 'one' after add().")
 	}
 
 	// Add a third one!
-	hn3 := hs.add("one", HandlerFunc(f)).(*hNode)
+	hn3 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
-	if hn3.set != hs || hn3.event != "one" {
-		t.Errorf("Third node for 'one' not created correctly")
-	}
-	if hn1.prev != nil || hn1.next != hn2 ||
-		hn2.prev != hn1 || hn2.next != hn3 ||
-		hn3.prev != hn2 || hn3.next != nil {
-		t.Errorf("Nodes for 'one' not linked correctly.")
-	}
-	if hl.start != hn1 || hl.end != hn3 {
-		t.Errorf("Node not appended to 'one' list correctly.")
+	if hl.Len() != 3 {
+		t.Errorf("List doesn't contain third 'one' after add().")
 	}
 
 	// And finally a fourth one!
-	hn4 := hs.add("one", HandlerFunc(f)).(*hNode)
+	hn4 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
-	if hn4.set != hs || hn4.event != "one" {
-		t.Errorf("Fourth node for 'one' not created correctly.")
-	}
-	if hn1.prev != nil || hn1.next != hn2 ||
-		hn2.prev != hn1 || hn2.next != hn3 ||
-		hn3.prev != hn2 || hn3.next != hn4 ||
-		hn4.prev != hn3 || hn4.next != nil {
-		t.Errorf("Nodes for 'one' not linked correctly.")
-	}
-	if hl.start != hn1 || hl.end != hn4 {
-		t.Errorf("Node not appended to 'one' list correctly.")
+	if hl.Len() != 4 {
+		t.Errorf("List doesn't contain fourth 'one' after add().")
 	}
 
 	// Dispatch should result in 4 additions.
@@ -94,16 +68,8 @@ func TestHandlerSet(t *testing.T) {
 	if len(hs.set) != 1 {
 		t.Errorf("Set list count changed after remove().")
 	}
-	if hn3.set != nil || hn3.prev != nil || hn3.next != nil {
-		t.Errorf("Third node for 'one' not removed correctly.")
-	}
-	if hn1.prev != nil || hn1.next != hn2 ||
-		hn2.prev != hn1 || hn2.next != hn4 ||
-		hn4.prev != hn2 || hn4.next != nil {
-		t.Errorf("Third node for 'one' not unlinked correctly.")
-	}
-	if hl.start != hn1 || hl.end != hn4 {
-		t.Errorf("Third node for 'one' changed list pointers.")
+	if hl.Len() != 3 {
+		t.Errorf("Third 'one' not removed correctly.")
 	}
 
 	// Dispatch should result in 3 additions.
@@ -114,18 +80,12 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Remove node 1.
-	hs.remove(hn1)
+	hn1.Remove()
 	if len(hs.set) != 1 {
 		t.Errorf("Set list count changed after remove().")
 	}
-	if hn1.set != nil || hn1.prev != nil || hn1.next != nil {
-		t.Errorf("First node for 'one' not removed correctly.")
-	}
-	if hn2.prev != nil || hn2.next != hn4 || hn4.prev != hn2 || hn4.next != nil {
-		t.Errorf("First node for 'one' not unlinked correctly.")
-	}
-	if hl.start != hn2 || hl.end != hn4 {
-		t.Errorf("First node for 'one' didn't change list pointers.")
+	if hl.Len() != 2 {
+		t.Errorf("First 'one' not removed correctly.")
 	}
 
 	// Dispatch should result in 2 additions.
@@ -140,14 +100,8 @@ func TestHandlerSet(t *testing.T) {
 	if len(hs.set) != 1 {
 		t.Errorf("Set list count changed after remove().")
 	}
-	if hn4.set != nil || hn4.prev != nil || hn4.next != nil {
-		t.Errorf("Fourth node for 'one' not removed correctly.")
-	}
-	if hn2.prev != nil || hn2.next != nil {
-		t.Errorf("Fourth node for 'one' not unlinked correctly.")
-	}
-	if hl.start != hn2 || hl.end != hn2 {
-		t.Errorf("Fourth node for 'one' didn't change list pointers.")
+	if hl.Len() != 1 {
+		t.Errorf("Fourth 'one' not removed correctly.")
 	}
 
 	// Dispatch should result in 1 addition.
@@ -158,16 +112,10 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Remove node 2.
-	hs.remove(hn2)
+	hn2.Remove()
 	if len(hs.set) != 0 {
 		t.Errorf("Removing last node in 'one' didn't remove list.")
 	}
-	if hn2.set != nil || hn2.prev != nil || hn2.next != nil {
-		t.Errorf("Second node for 'one' not removed correctly.")
-	}
-	if hl.start != nil || hl.end != nil {
-		t.Errorf("Second node for 'one' didn't change list pointers.")
-	}
 
 	// Dispatch should result in NO additions.
 	hs.dispatch(nil, &Line{Cmd: "One"})
@@ -178,52 +126,43 @@ func TestHandlerSet(t *testing.T) {
 }
 
 func TestCommandSet(t *testing.T) {
-	cs := commandSet()
-	if len(cs.set) != 0 {
-		t.Errorf("New set contains things!")
+	cl := newCommandList()
+	if cl.list.Len() != 0 {
+		t.Errorf("New list contains things!")
 	}
 
-	c := &command{
-		fn:   func(c *Conn, l *Line) {},
-		help: "wtf?",
+	cn1 := cl.add("one", HandlerFunc(func(c *Conn, l *Line) {}), 0)
+	if cl.list.Len() != 1 {
+		t.Errorf("Command 'one' not added to list correctly.")
 	}
 
-	cn1 := cs.add("ONE", c).(*cNode)
-	if _, ok := cs.set["one"]; !ok || cn1.set != cs || cn1.prefix != "one" {
-		t.Errorf("Command 'one' not added to set correctly.")
-	}
-
-	if fail := cs.add("one", c); fail != nil {
-		t.Errorf("Adding a second 'one' command did not fail as expected.")
-	}
-
-	cn2 := cs.add("One Two", c).(*cNode)
-	if _, ok := cs.set["one two"]; !ok || cn2.set != cs || cn2.prefix != "one two" {
+	cn2 := cl.add("one two", HandlerFunc(func(c *Conn, l *Line) {}), 0)
+	if cl.list.Len() != 2 {
 		t.Errorf("Command 'one two' not added to set correctly.")
 	}
 
-	if c, l := cs.match("foo"); c != nil || l != 0 {
+	if c := cl.match("foo"); c != nil {
 		t.Errorf("Matched 'foo' when we shouldn't.")
 	}
-	if c, l := cs.match("one"); c.(*cNode) != cn1 || l != 3 {
-		t.Errorf("Didn't match 'one' when we should have.")
+	if c := cl.match("one"); c == nil {
+		t.Errorf("Didn't match when we should have.")
 	}
-	if c, l := cs.match("one two three"); c.(*cNode) != cn2 || l != 7 {
-		t.Errorf("Didn't match 'one two' when we should have.")
+	if c := cl.match("one two three"); c == nil {
+		t.Errorf("Didn't match when we should have.")
 	}
 
-	cs.remove(cn2)
-	if _, ok := cs.set["one two"]; ok || cn2.set != nil {
+	cn2.Remove()
+	if cl.list.Len() != 1 {
 		t.Errorf("Command 'one two' not removed correctly.")
 	}
-	if c, l := cs.match("one two three"); c.(*cNode) != cn1 || l != 3 {
-		t.Errorf("Didn't match 'one' when we should have.")
+	if c := cl.match("one two three"); c == nil {
+		t.Errorf("Didn't match when we should have.")
 	}
 	cn1.Remove()
-	if _, ok := cs.set["one"]; ok || cn1.set != nil {
-		t.Errorf("Command 'one' not removed correctly.")
+	if cl.list.Len() != 0 {
+		t.Errorf("Command 'one two' not removed correctly.")
 	}
-	if c, l := cs.match("one two three"); c != nil || l != 0 {
-		t.Errorf("Matched 'one' when we shouldn't have.")
+	if c := cl.match("one two three"); c != nil {
+		t.Errorf("Matched 'one' when we shouldn't.")
 	}
 }
diff --git a/client/handlers.go b/client/handlers.go
index f5ded17..14774d3 100644
--- a/client/handlers.go
+++ b/client/handlers.go
@@ -97,5 +97,23 @@ func (conn *Conn) h_NICK(line *Line) {
 
 // Handle PRIVMSGs that trigger Commands
 func (conn *Conn) h_PRIVMSG(line *Line) {
-	conn.command(line)
+	text := line.Message()
+	if conn.CommandStripNick && strings.HasPrefix(text, conn.Me.Nick) {
+		// Look for '^${nick}[:;>,-]? '
+		l := len(conn.Me.Nick)
+		switch text[l] {
+		case ':', ';', '>', ',', '-':
+			l++
+		}
+		if text[l] == ' ' {
+			text = strings.TrimSpace(text[l:])
+		}
+		line = line.Copy()
+		line.Args[1] = text
+	}
+	cmd := conn.command(line)
+	if cmd == nil {
+		return
+	}
+	cmd.Handle(conn, line)
 }
diff --git a/client/handlers_test.go b/client/handlers_test.go
index 1389967..c6c0e28 100644
--- a/client/handlers_test.go
+++ b/client/handlers_test.go
@@ -146,7 +146,9 @@ func TestPRIVMSG(t *testing.T) {
 	f := func(conn *Conn, line *Line) {
 		conn.Privmsg(line.Args[0], line.Args[1])
 	}
-	c.CommandFunc("prefix", f, "")
+	// Test legacy simpleCommands, with out the !.
+	SimpleCommandRegex = `^%v(\s|$)`
+	c.SimpleCommandFunc("prefix", f)
 
 	// CommandStripNick and CommandStripPrefix are both false to begin
 	c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar"))
@@ -163,7 +165,7 @@ func TestPRIVMSG(t *testing.T) {
 	c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))
 	s.nc.Expect("PRIVMSG #foo :prefix bar")
 
-	c.CommandStripPrefix = true
+	c.SimpleCommandStripPrefix = true
 	c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar"))
 	s.nc.Expect("PRIVMSG #foo :bar")
 	c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar"))

From 99fe1b3624bc79d29027cfaddc915008eb31363d Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 19:09:10 -0800
Subject: [PATCH 08/13] Fix Readme

---
 README.md | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/README.md b/README.md
index dcf682b..89d1115 100644
--- a/README.md
+++ b/README.md
@@ -28,19 +28,11 @@ Synopsis:
 
 		// Add handlers to do things here!
 		// e.g. join a channel on connect.
-<<<<<<< HEAD
 		c.HandleFunc(irc.CONNECTED,
 			func(conn *irc.Conn, line *irc.Line) { conn.Join("#channel") })
 		// And a signal on disconnect
 		quit := make(chan bool)
 		c.HandleFunc(irc.DISCONNECTED,
-=======
-		c.HandleFunc("connected",
-			func(conn *irc.Conn, line *irc.Line) { conn.Join("#channel") })
-		// And a signal on disconnect
-		quit := make(chan bool)
-		c.HandleFunc("disconnected",
->>>>>>> fluffle/master
 			func(conn *irc.Conn, line *irc.Line) { quit <- true })
 
 		// Tell client to connect.

From f792080a07dc03d5d701c1cf783229f6be8f5268 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 19:10:38 -0800
Subject: [PATCH 09/13] Don't commit my client.go

---
 client.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/client.go b/client.go
index 35bd92e..e9482b0 100644
--- a/client.go
+++ b/client.go
@@ -11,17 +11,14 @@ import (
 	"strings"
 )
 
-var host *string = flag.String("host", "irc.synirc.net", "IRC server")
+var host *string = flag.String("host", "irc.freenode.net", "IRC server")
 var channel *string = flag.String("channel", "#go-nuts", "IRC channel")
-var nick *string = flag.String("nick", "Septapus", "Nick")
-var ident *string = flag.String("ident", "Septapus", "Ident")
-var name *string = flag.String("name", "Septapus v9", "Name")
 
 func main() {
 	flag.Parse()
 
 	// create new IRC connection
-	c := irc.SimpleClient(*nick, *ident, *name)
+	c := irc.SimpleClient("GoTest", "gotest")
 	c.EnableStateTracking()
 	c.HandleFunc(irc.CONNECTED,
 		func(conn *irc.Conn, line *irc.Line) { conn.Join(*channel) })

From c86a9a257d0464839360104b83d17952ac597f1e Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 19:12:43 -0800
Subject: [PATCH 10/13] Sigh

---
 client.go | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/client.go b/client.go
index e9482b0..a686cf8 100644
--- a/client.go
+++ b/client.go
@@ -111,13 +111,8 @@ func main() {
 
 	for !reallyquit {
 		// connect to server
-<<<<<<< HEAD
-		if err := c.Connect(*host); err != nil {
-			fmt.Printf("Error %v", err)
-=======
 		if err := c.ConnectTo(*host); err != nil {
 			fmt.Printf("Connection error: %s\n", err)
->>>>>>> fluffle/master
 			return
 		}
 		// wait on quit channel

From 6fc99107e65ee964a514f75d10ac9c6ce1c256e5 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Sun, 17 Feb 2013 22:02:02 -0800
Subject: [PATCH 11/13] Return the list element and the remover from the
 internal handlerSet/commandList methods.

This makes the remove method useful. Before it was only useful inside the Remove closures.
---
 client/dispatch.go      | 19 +++++++++++--------
 client/dispatch_test.go | 12 ++++++------
 2 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/client/dispatch.go b/client/dispatch.go
index 46794c3..672e7c0 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -46,7 +46,7 @@ func newHandlerSet() *handlerSet {
 	return &handlerSet{set: make(map[string]*list.List)}
 }
 
-func (hs *handlerSet) add(event string, handler Handler) Remover {
+func (hs *handlerSet) add(event string, handler Handler) (*list.Element, Remover) {
 	hs.Lock()
 	defer hs.Unlock()
 	event = strings.ToLower(event)
@@ -56,7 +56,7 @@ func (hs *handlerSet) add(event string, handler Handler) Remover {
 		hs.set[event] = l
 	}
 	element := l.PushBack(&handlerElement{event, handler})
-	return RemoverFunc(func() {
+	return element, RemoverFunc(func() {
 		hs.remove(element)
 	})
 }
@@ -106,7 +106,7 @@ func newCommandList() *commandList {
 	return &commandList{list: list.New()}
 }
 
-func (cl *commandList) add(regex string, handler Handler, priority int) Remover {
+func (cl *commandList) add(regex string, handler Handler, priority int) (element *list.Element, remover Remover) {
 	cl.Lock()
 	defer cl.Unlock()
 	c := &commandElement{
@@ -119,13 +119,14 @@ func (cl *commandList) add(regex string, handler Handler, priority int) Remover
 		c := e.Value.(*commandElement)
 		if c.regex == regex {
 			logging.Error("Command prefix '%s' already registered.", regex)
-			return nil
+			return
 		}
 	}
-	element := cl.list.PushBack(c)
-	return RemoverFunc(func() {
+	element = cl.list.PushBack(c)
+	remover = RemoverFunc(func() {
 		cl.remove(element)
 	})
+	return
 }
 
 func (cl *commandList) remove(element *list.Element) {
@@ -161,7 +162,8 @@ func (cl *commandList) match(text string) (handler Handler) {
 // strings of digits like "332" (mainly because I really didn't feel like
 // putting massive constant tables in).
 func (conn *Conn) Handle(name string, handler Handler) Remover {
-	return conn.handlers.add(name, handler)
+	_, remover := conn.handlers.add(name, handler)
+	return remover
 }
 
 func (conn *Conn) HandleFunc(name string, handlerFunc HandlerFunc) Remover {
@@ -169,7 +171,8 @@ func (conn *Conn) HandleFunc(name string, handlerFunc HandlerFunc) Remover {
 }
 
 func (conn *Conn) Command(regex string, handler Handler, priority int) Remover {
-	return conn.commands.add(regex, handler, priority)
+	_, remover := conn.commands.add(regex, handler, priority)
+	return remover
 }
 
 func (conn *Conn) CommandFunc(regex string, handlerFunc HandlerFunc, priority int) Remover {
diff --git a/client/dispatch_test.go b/client/dispatch_test.go
index 1e3caca..101afcf 100644
--- a/client/dispatch_test.go
+++ b/client/dispatch_test.go
@@ -17,7 +17,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Add one
-	hn1 := hs.add("ONE", HandlerFunc(f))
+	_, hn1 := hs.add("ONE", HandlerFunc(f))
 	hl, ok := hs.set["one"]
 	if len(hs.set) != 1 || !ok {
 		t.Errorf("Set doesn't contain 'one' list after add().")
@@ -27,7 +27,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Add another one...
-	hn2 := hs.add("one", HandlerFunc(f))
+	_, hn2 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
@@ -36,7 +36,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// Add a third one!
-	hn3 := hs.add("one", HandlerFunc(f))
+	_, hn3 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
@@ -45,7 +45,7 @@ func TestHandlerSet(t *testing.T) {
 	}
 
 	// And finally a fourth one!
-	hn4 := hs.add("one", HandlerFunc(f))
+	_, hn4 := hs.add("one", HandlerFunc(f))
 	if len(hs.set) != 1 {
 		t.Errorf("Set contains more than 'one' list after add().")
 	}
@@ -131,12 +131,12 @@ func TestCommandSet(t *testing.T) {
 		t.Errorf("New list contains things!")
 	}
 
-	cn1 := cl.add("one", HandlerFunc(func(c *Conn, l *Line) {}), 0)
+	_, cn1 := cl.add("one", HandlerFunc(func(c *Conn, l *Line) {}), 0)
 	if cl.list.Len() != 1 {
 		t.Errorf("Command 'one' not added to list correctly.")
 	}
 
-	cn2 := cl.add("one two", HandlerFunc(func(c *Conn, l *Line) {}), 0)
+	_, cn2 := cl.add("one two", HandlerFunc(func(c *Conn, l *Line) {}), 0)
 	if cl.list.Len() != 2 {
 		t.Errorf("Command 'one two' not added to set correctly.")
 	}

From ab3ac231da829dd1aeca4dba9aeb0498645a2da2 Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Mon, 18 Feb 2013 12:01:32 -0800
Subject: [PATCH 12/13] Clean up SimpleCommand, less casting.

---
 client/dispatch.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/dispatch.go b/client/dispatch.go
index 672e7c0..a51db93 100644
--- a/client/dispatch.go
+++ b/client/dispatch.go
@@ -197,7 +197,7 @@ func (conn *Conn) SimpleCommand(prefix string, handler Handler) Remover {
 		}
 		handler.Handle(conn, line)
 	}
-	return conn.Command(fmt.Sprintf(SimpleCommandRegex, strings.ToLower(prefix)), HandlerFunc(stripHandler), math.MaxInt32)
+	return conn.CommandFunc(fmt.Sprintf(SimpleCommandRegex, strings.ToLower(prefix)), stripHandler, math.MaxInt32)
 }
 
 func (conn *Conn) SimpleCommandFunc(prefix string, handlerFunc HandlerFunc) Remover {

From 4a4c7f397c6b68913ded21b792e4b41620e852ee Mon Sep 17 00:00:00 2001
From: Chris Rhodes <iopred@gmail.com>
Date: Mon, 18 Feb 2013 17:33:55 -0800
Subject: [PATCH 13/13] Regexes are consts.

---
 client/funcs.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/client/funcs.go b/client/funcs.go
index 0e8cec9..61c9c12 100644
--- a/client/funcs.go
+++ b/client/funcs.go
@@ -29,7 +29,7 @@ type youTubeVideo struct {
 	} `json:entry`
 }
 
-var UrlRegex string = `(\s|^)(http://|https://)(.*?)(\s|$)`
+const UrlRegex string = `(\s|^)(http://|https://)(.*?)(\s|$)`
 
 func UrlFunc(conn *Conn, line *Line) {
 	text := line.Message()
@@ -52,7 +52,7 @@ func UrlFunc(conn *Conn, line *Line) {
 	}
 }
 
-var YouTubeRegex string = `(\s|^)(http://|https://)?(www.)?(youtube.com/watch\?v=|youtu.be/)(.*?)(\s|$|\&|#)`
+const YouTubeRegex string = `(\s|^)(http://|https://)?(www.)?(youtube.com/watch\?v=|youtu.be/)(.*?)(\s|$|\&|#)`
 
 func YouTubeFunc(conn *Conn, line *Line) {
 	text := line.Message()