From f27e56c8b0fb41530da12c84f4e03a4e7334c53c Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Sat, 16 Feb 2013 10:33:15 +0000 Subject: [PATCH 1/4] Run gofmt, since it's clearly been a while. --- client.go | 4 ++-- client/connection.go | 2 +- client/connection_test.go | 16 ++++++++-------- client/dispatch.go | 4 +++- client/dispatch_test.go | 20 ++++++++++---------- client/handlers.go | 8 +++++--- client/handlers_test.go | 8 +++----- client/line_test.go | 14 +++++++------- client/state_handlers.go | 24 ++++++++++++------------ 9 files changed, 51 insertions(+), 49 deletions(-) diff --git a/client.go b/client.go index cb8d02f..de4ae52 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" ) diff --git a/client/connection.go b/client/connection.go index dce6c43..35e3027 100644 --- a/client/connection.go +++ b/client/connection.go @@ -60,7 +60,7 @@ type Conn struct { Flood bool // Internal counters for flood protection - badness time.Duration + badness time.Duration lastsent time.Time } diff --git a/client/connection_test.go b/client/connection_test.go index 6386eb3..40ebd7d 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" @@ -57,7 +57,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 +356,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 +470,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 +491,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..d6ab8b2 100644 --- a/client/handlers.go +++ b/client/handlers.go @@ -9,8 +9,8 @@ import ( // sets up the internal event handlers to do essential IRC protocol things var intHandlers = map[string]HandlerFunc{ - "001": (*Conn).h_001, - "433": (*Conn).h_433, + "001": (*Conn).h_001, + "433": (*Conn).h_433, "CTCP": (*Conn).h_CTCP, "NICK": (*Conn).h_NICK, "PING": (*Conn).h_PING, @@ -99,7 +99,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..846644c 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_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 a88b866b63e3ab4db307c864b0d160bb9eaccc1c Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Sat, 16 Feb 2013 11:04:06 +0000 Subject: [PATCH 2/4] Fix up README and example client. --- README.md | 6 +++--- client.go | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 5f22864..0f8bc11 100644 --- a/README.md +++ b/README.md @@ -18,17 +18,17 @@ Synopsis: func main() { flag.Parse() // parses the logging flags. - c := irc.SimpleClient("nick") + c := irc.Client("nick") // Optionally, enable SSL c.SSL = true // Add handlers to do things here! // e.g. join a channel on connect. - c.AddHandler("connected", + c.HandleFunc("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("disconnected", func(conn *irc.Conn, line *irc.Line) { quit <- true }) // Tell client to connect diff --git a/client.go b/client.go index de4ae52..848bd41 100644 --- a/client.go +++ b/client.go @@ -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("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("disconnected", func(conn *irc.Conn, line *irc.Line) { quit <- true }) // set up a goroutine to read commands from stdin From 45d7b3317f2ff58ed62b3b3b162137258f0fa8ad Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Sat, 16 Feb 2013 11:29:56 +0000 Subject: [PATCH 3/4] Remove state.StateTracker stutter, hide it in Conn. --- client/connection.go | 29 ++++++++-------- client/connection_test.go | 15 ++++---- client/handlers.go | 6 ++-- client/handlers_test.go | 8 ++--- client/state_handlers.go | 48 +++++++++++++------------- state/mock_tracker.go | 72 +++++++++++++++++++-------------------- state/tracker.go | 36 ++++++++++---------- 7 files changed, 107 insertions(+), 107 deletions(-) diff --git a/client/connection.go b/client/connection.go index 35e3027..4fda637 100644 --- a/client/connection.go +++ b/client/connection.go @@ -24,8 +24,7 @@ type Conn struct { commands *cSet // State tracker for nicks and channels - ST state.StateTracker - st bool + st state.Tracker stRemovers []Remover // Use the State field to store external state that handlers might need. @@ -100,32 +99,34 @@ func Client(nick string, args ...string) *Conn { } func (conn *Conn) EnableStateTracking() { - if !conn.st { + if conn.st == nil { n := conn.Me - conn.ST = state.NewTracker(n.Nick) - conn.Me = conn.ST.Me() + conn.st = state.NewTracker(n.Nick) + conn.Me = conn.st.Me() conn.Me.Ident = n.Ident conn.Me.Name = n.Name conn.addSTHandlers() - conn.st = true } } func (conn *Conn) DisableStateTracking() { - if conn.st { - conn.st = false + if conn.st != nil { conn.delSTHandlers() - conn.ST.Wipe() - conn.ST = nil + conn.st.Wipe() + conn.st = nil } } +func (conn *Conn) StateTracker() state.Tracker { + return conn.st +} + // Per-connection state initialisation. func (conn *Conn) initialise() { conn.io = nil conn.sock = nil - if conn.st { - conn.ST.Wipe() + if conn.st != nil { + conn.st.Wipe() } } @@ -328,8 +329,8 @@ func (conn *Conn) String() string { str += "Not currently connected!\n\n" } str += conn.Me.String() + "\n" - if conn.st { - str += conn.ST.String() + "\n" + if conn.st != nil { + str += conn.st.String() + "\n" } return str } diff --git a/client/connection_test.go b/client/connection_test.go index 40ebd7d..f8b5950 100644 --- a/client/connection_test.go +++ b/client/connection_test.go @@ -12,20 +12,19 @@ import ( type testState struct { ctrl *gomock.Controller - st *state.MockStateTracker + st *state.MockTracker nc *mockNetConn c *Conn } func setUp(t *testing.T, start ...bool) (*Conn, *testState) { ctrl := gomock.NewController(t) - st := state.NewMockStateTracker(ctrl) + st := state.NewMockTracker(ctrl) nc := MockNetConn(t) c := Client("test", "test", "Testing IRC") logging.SetLogLevel(logging.LogFatal) - c.ST = st - c.st = true + c.st = st c.sock = nc c.Flood = true // Tests can take a while otherwise c.Connected = true @@ -82,7 +81,7 @@ func TestEOF(t *testing.T) { func TestClientAndStateTracking(t *testing.T) { ctrl := gomock.NewController(t) - st := state.NewMockStateTracker(ctrl) + st := state.NewMockTracker(ctrl) c := Client("test", "test", "Testing IRC") // Assert some basic things about the initial state of the Conn struct @@ -114,16 +113,16 @@ func TestClientAndStateTracking(t *testing.T) { c.Me.Name != "Testing IRC" || c.Me.Host != "" { t.Errorf("Enabling state tracking did not replace Me correctly.") } - if !c.st || c.ST == nil || c.Me != c.ST.Me() { + if c.st == nil || c.Me != c.st.Me() { t.Errorf("State tracker not enabled correctly.") } // Now, shim in the mock state tracker and test disabling state tracking me := c.Me - c.ST = st + c.st = st st.EXPECT().Wipe() c.DisableStateTracking() - if c.st || c.ST != nil || c.Me != me { + if c.st != nil || c.Me != me { t.Errorf("State tracker not disabled correctly.") } diff --git a/client/handlers.go b/client/handlers.go index d6ab8b2..6b34977 100644 --- a/client/handlers.go +++ b/client/handlers.go @@ -60,8 +60,8 @@ func (conn *Conn) h_433(line *Line) { // we sent in the initial NICK command is in use) we will not receive // a NICK message to confirm our change of nick, so ReNick here... if line.Args[1] == conn.Me.Nick { - if conn.st { - conn.ST.ReNick(conn.Me.Nick, neu) + if conn.st != nil { + conn.st.ReNick(conn.Me.Nick, neu) } else { conn.Me.Nick = neu } @@ -79,7 +79,7 @@ func (conn *Conn) h_CTCP(line *Line) { // Handle updating our own NICK if we're not using the state tracker func (conn *Conn) h_NICK(line *Line) { - if !conn.st && line.Nick == conn.Me.Nick { + if conn.st == nil && line.Nick == conn.Me.Nick { conn.Me.Nick = line.Args[0] } } diff --git a/client/handlers_test.go b/client/handlers_test.go index 846644c..1231bab 100644 --- a/client/handlers_test.go +++ b/client/handlers_test.go @@ -74,14 +74,14 @@ func Test433(t *testing.T) { } // Test the code path that *doesn't* involve state tracking. - c.st = false + c.st = nil c.h_433(parseLine(":irc.server.org 433 test test :Nickname is already in use.")) s.nc.Expect("NICK test_") if c.Me.Nick != "test_" { t.Errorf("My nick not updated from '%s'.", c.Me.Nick) } - c.st = true + c.st = s.st } // Test the handler for NICK messages when state tracking is disabled @@ -90,7 +90,7 @@ func TestNICK(t *testing.T) { defer s.tearDown() // State tracking is enabled by default in setUp - c.st = false + c.st = nil // Call handler with a NICK line changing "our" nick to test1. c.h_NICK(parseLine(":test!test@somehost.com NICK :test1")) @@ -109,7 +109,7 @@ func TestNICK(t *testing.T) { } // Re-enable state tracking and send a line that *should* change nick. - c.st = true + c.st = s.st c.h_NICK(parseLine(":test1!test@somehost.com NICK :test2")) // Verify that our Nick hasn't changed (should be handled by h_STNICK). diff --git a/client/state_handlers.go b/client/state_handlers.go index ffc9211..44758be 100644 --- a/client/state_handlers.go +++ b/client/state_handlers.go @@ -40,13 +40,13 @@ func (conn *Conn) delSTHandlers() { // Handle NICK messages that need to update the state tracker func (conn *Conn) h_STNICK(line *Line) { // all nicks should be handled the same way, our own included - conn.ST.ReNick(line.Nick, line.Args[0]) + conn.st.ReNick(line.Nick, line.Args[0]) } // Handle JOINs to channels to maintain state func (conn *Conn) h_JOIN(line *Line) { - ch := conn.ST.GetChannel(line.Args[0]) - nk := conn.ST.GetNick(line.Nick) + ch := conn.st.GetChannel(line.Args[0]) + nk := conn.st.GetNick(line.Nick) if ch == nil { // first we've seen of this channel, so should be us joining it // NOTE this will also take care of nk == nil && ch == nil @@ -55,7 +55,7 @@ func (conn *Conn) h_JOIN(line *Line) { "from (non-me) nick %s", line.Args[0], line.Nick) return } - ch = conn.ST.NewChannel(line.Args[0]) + ch = conn.st.NewChannel(line.Args[0]) // since we don't know much about this channel, ask server for info // we get the channel users automatically in 353 and the channel // topic in 332 on join, so we just need to get the modes @@ -66,41 +66,41 @@ func (conn *Conn) h_JOIN(line *Line) { } if nk == nil { // this is the first we've seen of this nick - nk = conn.ST.NewNick(line.Nick) + nk = conn.st.NewNick(line.Nick) nk.Ident = line.Ident nk.Host = line.Host // since we don't know much about this nick, ask server for info conn.Who(nk.Nick) } // this takes care of both nick and channel linking \o/ - conn.ST.Associate(ch, nk) + conn.st.Associate(ch, nk) } // Handle PARTs from channels to maintain state func (conn *Conn) h_PART(line *Line) { - conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]), - conn.ST.GetNick(line.Nick)) + conn.st.Dissociate(conn.st.GetChannel(line.Args[0]), + conn.st.GetNick(line.Nick)) } // Handle KICKs from channels to maintain state func (conn *Conn) h_KICK(line *Line) { // XXX: this won't handle autorejoining channels on KICK // it's trivial to do this in a seperate handler... - conn.ST.Dissociate(conn.ST.GetChannel(line.Args[0]), - conn.ST.GetNick(line.Args[1])) + conn.st.Dissociate(conn.st.GetChannel(line.Args[0]), + conn.st.GetNick(line.Args[1])) } // Handle other people's QUITs func (conn *Conn) h_QUIT(line *Line) { - conn.ST.DelNick(line.Nick) + conn.st.DelNick(line.Nick) } // Handle MODE changes for channels we know about (and our nick personally) func (conn *Conn) h_MODE(line *Line) { - if ch := conn.ST.GetChannel(line.Args[0]); ch != nil { + if ch := conn.st.GetChannel(line.Args[0]); ch != nil { // channel modes first ch.ParseModes(line.Args[1], line.Args[2:]...) - } else if nk := conn.ST.GetNick(line.Args[0]); nk != nil { + } else if nk := conn.st.GetNick(line.Args[0]); nk != nil { // nick mode change, should be us if nk != conn.Me { logging.Warn("irc.MODE(): recieved MODE %s for (non-me) nick %s", @@ -116,7 +116,7 @@ func (conn *Conn) h_MODE(line *Line) { // Handle TOPIC changes for channels func (conn *Conn) h_TOPIC(line *Line) { - if ch := conn.ST.GetChannel(line.Args[0]); ch != nil { + if ch := conn.st.GetChannel(line.Args[0]); ch != nil { ch.Topic = line.Args[1] } else { logging.Warn("irc.TOPIC(): topic change on unknown channel %s", @@ -126,7 +126,7 @@ func (conn *Conn) h_TOPIC(line *Line) { // Handle 311 whois reply func (conn *Conn) h_311(line *Line) { - if nk := conn.ST.GetNick(line.Args[1]); nk != nil { + if nk := conn.st.GetNick(line.Args[1]); nk != nil { nk.Ident = line.Args[2] nk.Host = line.Args[3] nk.Name = line.Args[5] @@ -138,7 +138,7 @@ func (conn *Conn) h_311(line *Line) { // Handle 324 mode reply func (conn *Conn) h_324(line *Line) { - if ch := conn.ST.GetChannel(line.Args[1]); ch != nil { + if ch := conn.st.GetChannel(line.Args[1]); ch != nil { ch.ParseModes(line.Args[2], line.Args[3:]...) } else { logging.Warn("irc.324(): received MODE settings for unknown channel %s", @@ -148,7 +148,7 @@ func (conn *Conn) h_324(line *Line) { // Handle 332 topic reply on join to channel func (conn *Conn) h_332(line *Line) { - if ch := conn.ST.GetChannel(line.Args[1]); ch != nil { + if ch := conn.st.GetChannel(line.Args[1]); ch != nil { ch.Topic = line.Args[2] } else { logging.Warn("irc.332(): received TOPIC value for unknown channel %s", @@ -158,7 +158,7 @@ func (conn *Conn) h_332(line *Line) { // Handle 352 who reply func (conn *Conn) h_352(line *Line) { - if nk := conn.ST.GetNick(line.Args[5]); nk != nil { + if nk := conn.st.GetNick(line.Args[5]); nk != nil { nk.Ident = line.Args[2] nk.Host = line.Args[3] // XXX: do we care about the actual server the nick is on? @@ -180,7 +180,7 @@ func (conn *Conn) h_352(line *Line) { // Handle 353 names reply func (conn *Conn) h_353(line *Line) { - if ch := conn.ST.GetChannel(line.Args[2]); ch != nil { + if ch := conn.st.GetChannel(line.Args[2]); ch != nil { nicks := strings.Split(line.Args[len(line.Args)-1], " ") for _, nick := range nicks { // UnrealIRCd's coders are lazy and leave a trailing space @@ -192,15 +192,15 @@ func (conn *Conn) h_353(line *Line) { nick = nick[1:] fallthrough default: - nk := conn.ST.GetNick(nick) + nk := conn.st.GetNick(nick) if nk == nil { // we don't know this nick yet! - nk = conn.ST.NewNick(nick) + nk = conn.st.NewNick(nick) } - cp, ok := conn.ST.IsOn(ch.Name, nick) + cp, ok := conn.st.IsOn(ch.Name, nick) if !ok { // This nick isn't associated with this channel yet! - cp = conn.ST.Associate(ch, nk) + cp = conn.st.Associate(ch, nk) } switch c { case '~': @@ -224,7 +224,7 @@ func (conn *Conn) h_353(line *Line) { // Handle 671 whois reply (nick connected via SSL) func (conn *Conn) h_671(line *Line) { - if nk := conn.ST.GetNick(line.Args[1]); nk != nil { + if nk := conn.st.GetNick(line.Args[1]); nk != nil { nk.Modes.SSL = true } else { logging.Warn("irc.671(): received WHOIS SSL info for unknown nick %s", diff --git a/state/mock_tracker.go b/state/mock_tracker.go index 2be887e..310b5b7 100644 --- a/state/mock_tracker.go +++ b/state/mock_tracker.go @@ -7,144 +7,144 @@ import ( gomock "code.google.com/p/gomock/gomock" ) -// Mock of StateTracker interface -type MockStateTracker struct { +// Mock of Tracker interface +type MockTracker struct { ctrl *gomock.Controller - recorder *_MockStateTrackerRecorder + recorder *_MockTrackerRecorder } -// Recorder for MockStateTracker (not exported) -type _MockStateTrackerRecorder struct { - mock *MockStateTracker +// Recorder for MockTracker (not exported) +type _MockTrackerRecorder struct { + mock *MockTracker } -func NewMockStateTracker(ctrl *gomock.Controller) *MockStateTracker { - mock := &MockStateTracker{ctrl: ctrl} - mock.recorder = &_MockStateTrackerRecorder{mock} +func NewMockTracker(ctrl *gomock.Controller) *MockTracker { + mock := &MockTracker{ctrl: ctrl} + mock.recorder = &_MockTrackerRecorder{mock} return mock } -func (_m *MockStateTracker) EXPECT() *_MockStateTrackerRecorder { +func (_m *MockTracker) EXPECT() *_MockTrackerRecorder { return _m.recorder } -func (_m *MockStateTracker) NewNick(nick string) *Nick { +func (_m *MockTracker) NewNick(nick string) *Nick { ret := _m.ctrl.Call(_m, "NewNick", nick) ret0, _ := ret[0].(*Nick) return ret0 } -func (_mr *_MockStateTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) NewNick(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "NewNick", arg0) } -func (_m *MockStateTracker) GetNick(nick string) *Nick { +func (_m *MockTracker) GetNick(nick string) *Nick { ret := _m.ctrl.Call(_m, "GetNick", nick) ret0, _ := ret[0].(*Nick) return ret0 } -func (_mr *_MockStateTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) GetNick(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetNick", arg0) } -func (_m *MockStateTracker) ReNick(old string, neu string) { +func (_m *MockTracker) ReNick(old string, neu string) { _m.ctrl.Call(_m, "ReNick", old, neu) } -func (_mr *_MockStateTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) ReNick(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "ReNick", arg0, arg1) } -func (_m *MockStateTracker) DelNick(nick string) { +func (_m *MockTracker) DelNick(nick string) { _m.ctrl.Call(_m, "DelNick", nick) } -func (_mr *_MockStateTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) DelNick(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "DelNick", arg0) } -func (_m *MockStateTracker) NewChannel(channel string) *Channel { +func (_m *MockTracker) NewChannel(channel string) *Channel { ret := _m.ctrl.Call(_m, "NewChannel", channel) ret0, _ := ret[0].(*Channel) return ret0 } -func (_mr *_MockStateTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) NewChannel(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "NewChannel", arg0) } -func (_m *MockStateTracker) GetChannel(channel string) *Channel { +func (_m *MockTracker) GetChannel(channel string) *Channel { ret := _m.ctrl.Call(_m, "GetChannel", channel) ret0, _ := ret[0].(*Channel) return ret0 } -func (_mr *_MockStateTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) GetChannel(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "GetChannel", arg0) } -func (_m *MockStateTracker) DelChannel(channel string) { +func (_m *MockTracker) DelChannel(channel string) { _m.ctrl.Call(_m, "DelChannel", channel) } -func (_mr *_MockStateTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) DelChannel(arg0 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "DelChannel", arg0) } -func (_m *MockStateTracker) Me() *Nick { +func (_m *MockTracker) Me() *Nick { ret := _m.ctrl.Call(_m, "Me") ret0, _ := ret[0].(*Nick) return ret0 } -func (_mr *_MockStateTrackerRecorder) Me() *gomock.Call { +func (_mr *_MockTrackerRecorder) Me() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Me") } -func (_m *MockStateTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) { +func (_m *MockTracker) IsOn(channel string, nick string) (*ChanPrivs, bool) { ret := _m.ctrl.Call(_m, "IsOn", channel, nick) ret0, _ := ret[0].(*ChanPrivs) ret1, _ := ret[1].(bool) return ret0, ret1 } -func (_mr *_MockStateTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) IsOn(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "IsOn", arg0, arg1) } -func (_m *MockStateTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs { +func (_m *MockTracker) Associate(channel *Channel, nick *Nick) *ChanPrivs { ret := _m.ctrl.Call(_m, "Associate", channel, nick) ret0, _ := ret[0].(*ChanPrivs) return ret0 } -func (_mr *_MockStateTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) Associate(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Associate", arg0, arg1) } -func (_m *MockStateTracker) Dissociate(channel *Channel, nick *Nick) { +func (_m *MockTracker) Dissociate(channel *Channel, nick *Nick) { _m.ctrl.Call(_m, "Dissociate", channel, nick) } -func (_mr *_MockStateTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call { +func (_mr *_MockTrackerRecorder) Dissociate(arg0, arg1 interface{}) *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Dissociate", arg0, arg1) } -func (_m *MockStateTracker) Wipe() { +func (_m *MockTracker) Wipe() { _m.ctrl.Call(_m, "Wipe") } -func (_mr *_MockStateTrackerRecorder) Wipe() *gomock.Call { +func (_mr *_MockTrackerRecorder) Wipe() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "Wipe") } -func (_m *MockStateTracker) String() string { +func (_m *MockTracker) String() string { ret := _m.ctrl.Call(_m, "String") ret0, _ := ret[0].(string) return ret0 } -func (_mr *_MockStateTrackerRecorder) String() *gomock.Call { +func (_mr *_MockTrackerRecorder) String() *gomock.Call { return _mr.mock.ctrl.RecordCall(_mr.mock, "String") } diff --git a/state/tracker.go b/state/tracker.go index fb29cd2..893b68d 100644 --- a/state/tracker.go +++ b/state/tracker.go @@ -5,7 +5,7 @@ import ( ) // The state manager interface -type StateTracker interface { +type Tracker interface { // Nick methods NewNick(nick string) *Nick GetNick(nick string) *Nick @@ -63,7 +63,7 @@ func (st *stateTracker) Wipe() { // can be properly tracked for state management purposes. func (st *stateTracker) NewNick(n string) *Nick { if _, ok := st.nicks[n]; ok { - logging.Warn("StateTracker.NewNick(): %s already tracked.", n) + logging.Warn("Tracker.NewNick(): %s already tracked.", n) return nil } st.nicks[n] = NewNick(n) @@ -93,10 +93,10 @@ func (st *stateTracker) ReNick(old, neu string) { ch.lookup[neu] = nk } } else { - logging.Warn("StateTracker.ReNick(): %s already exists.", neu) + logging.Warn("Tracker.ReNick(): %s already exists.", neu) } } else { - logging.Warn("StateTracker.ReNick(): %s not tracked.", old) + logging.Warn("Tracker.ReNick(): %s not tracked.", old) } } @@ -106,17 +106,17 @@ func (st *stateTracker) DelNick(n string) { if nk != st.me { st.delNick(nk) } else { - logging.Warn("StateTracker.DelNick(): won't delete myself.") + logging.Warn("Tracker.DelNick(): won't delete myself.") } } else { - logging.Warn("StateTracker.DelNick(): %s not tracked.", n) + logging.Warn("Tracker.DelNick(): %s not tracked.", n) } } func (st *stateTracker) delNick(nk *Nick) { if nk == st.me { // Shouldn't get here => internal state tracking code is fubar. - logging.Error("StateTracker.DelNick(): TRYING TO DELETE ME :-(") + logging.Error("Tracker.DelNick(): TRYING TO DELETE ME :-(") return } delete(st.nicks, nk.Nick) @@ -126,7 +126,7 @@ func (st *stateTracker) delNick(nk *Nick) { if len(ch.nicks) == 0 { // Deleting a nick from tracking shouldn't empty any channels as // *we* should be on the channel with them to be tracking them. - logging.Error("StateTracker.delNick(): deleting nick %s emptied "+ + logging.Error("Tracker.delNick(): deleting nick %s emptied "+ "channel %s, this shouldn't happen!", nk.Nick, ch.Name) } } @@ -136,7 +136,7 @@ func (st *stateTracker) delNick(nk *Nick) { // can be properly tracked for state management purposes. func (st *stateTracker) NewChannel(c string) *Channel { if _, ok := st.chans[c]; ok { - logging.Warn("StateTracker.NewChannel(): %s already tracked.", c) + logging.Warn("Tracker.NewChannel(): %s already tracked.", c) return nil } st.chans[c] = NewChannel(c) @@ -156,7 +156,7 @@ func (st *stateTracker) DelChannel(c string) { if ch, ok := st.chans[c]; ok { st.delChannel(ch) } else { - logging.Warn("StateTracker.DelChannel(): %s not tracked.", c) + logging.Warn("Tracker.DelChannel(): %s not tracked.", c) } } @@ -191,21 +191,21 @@ func (st *stateTracker) IsOn(c, n string) (*ChanPrivs, bool) { // Associates an already known nick with an already known channel. func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { if ch == nil || nk == nil { - logging.Error("StateTracker.Associate(): passed nil values :-(") + logging.Error("Tracker.Associate(): passed nil values :-(") return nil } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { // As we can implicitly delete both nicks and channels from being // tracked by dissociating one from the other, we should verify that // we're not being passed an old Nick or Channel. - logging.Error("StateTracker.Associate(): channel %s not found in "+ + logging.Error("Tracker.Associate(): channel %s not found in "+ "(or differs from) internal state.", ch.Name) return nil } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { - logging.Error("StateTracker.Associate(): nick %s not found in "+ + logging.Error("Tracker.Associate(): nick %s not found in "+ "(or differs from) internal state.", nk.Nick) return nil } else if _, ok := nk.IsOn(ch); ok { - logging.Warn("StateTracker.Associate(): %s already on %s.", + logging.Warn("Tracker.Associate(): %s already on %s.", nk.Nick, ch.Name) return nil } @@ -220,18 +220,18 @@ func (st *stateTracker) Associate(ch *Channel, nk *Nick) *ChanPrivs { // any common channels with, and channels we're no longer on. func (st *stateTracker) Dissociate(ch *Channel, nk *Nick) { if ch == nil || nk == nil { - logging.Error("StateTracker.Dissociate(): passed nil values :-(") + logging.Error("Tracker.Dissociate(): passed nil values :-(") } else if _ch, ok := st.chans[ch.Name]; !ok || ch != _ch { // As we can implicitly delete both nicks and channels from being // tracked by dissociating one from the other, we should verify that // we're not being passed an old Nick or Channel. - logging.Error("StateTracker.Dissociate(): channel %s not found in "+ + logging.Error("Tracker.Dissociate(): channel %s not found in "+ "(or differs from) internal state.", ch.Name) } else if _nk, ok := st.nicks[nk.Nick]; !ok || nk != _nk { - logging.Error("StateTracker.Dissociate(): nick %s not found in "+ + logging.Error("Tracker.Dissociate(): nick %s not found in "+ "(or differs from) internal state.", nk.Nick) } else if _, ok := nk.IsOn(ch); !ok { - logging.Warn("StateTracker.Dissociate(): %s not on %s.", + logging.Warn("Tracker.Dissociate(): %s not on %s.", nk.Nick, ch.Name) } else if nk == st.me { // I'm leaving the channel for some reason, so it won't be tracked. From b1242aa351cb09654cd326421263993beee1d30d Mon Sep 17 00:00:00 2001 From: Alex Bramley Date: Sat, 16 Feb 2013 18:05:56 +0000 Subject: [PATCH 4/4] Break out tweakable things into a Config struct. --- client/connection.go | 90 +++++++++++++++++++++++++-------------- client/connection_test.go | 12 +++--- client/handlers.go | 6 +-- client/handlers_test.go | 8 ++-- 4 files changed, 71 insertions(+), 45 deletions(-) diff --git a/client/connection.go b/client/connection.go index 4fda637..7d18bec 100644 --- a/client/connection.go +++ b/client/connection.go @@ -14,10 +14,18 @@ import ( // An IRC connection is represented by this struct. type Conn struct { - // Connection Hostname and Nickname - Host string - Me *state.Nick - Network string + // Connection related vars people will care about + Me *state.Nick + Host string + Network string + Connected bool + + // Deprecated: future work to turn Conn into an interface will break this. + // Use the State field to store external state that handlers might need. + State interface{} + + // Contains parameters that people can tweak to change client behaviour. + cfg *Config // Handlers and Commands handlers *hSet @@ -27,21 +35,25 @@ type Conn struct { st state.Tracker stRemovers []Remover - // Use the State field to store external state that handlers might need. - // Remember ... you might need locking for this ;-) - State interface{} - // I/O stuff to server sock net.Conn io *bufio.ReadWriter in chan *Line out chan string - Connected bool // Control channels to goroutines cSend, cLoop, cPing chan bool - // Misc knobs to tweak client behaviour: + // Internal counters for flood protection + badness time.Duration + lastsent time.Time +} + +// Misc knobs to tweak client behaviour go in here +type Config struct { + // Set this to provide the Nick, Ident and Name for the client to use. + Me *state.Nick + // Are we connecting via SSL? Do we care about certificate validity? SSL bool SSLConfig *tls.Config @@ -57,16 +69,9 @@ type Conn struct { // Set this to true to disable flood protection and false to re-enable Flood bool - - // Internal counters for flood protection - badness time.Duration - lastsent time.Time } -// Creates a new IRC connection object, but doesn't connect to anything so -// that you can add event handlers to it. See AddHandler() for details -func Client(nick string, args ...string) *Conn { - logging.InitFromFlags() +func NewConfig(nick string, args ...string) *Config { ident := "goirc" name := "Powered by GoIRC" @@ -76,7 +81,30 @@ func Client(nick string, args ...string) *Conn { if len(args) > 1 && args[1] != "" { name = args[1] } + cfg := &Config{ + PingFreq: 3 * time.Minute, + NewNick: func(s string) string { return s + "_" }, + } + cfg.Me = state.NewNick(nick) + cfg.Me.Ident = ident + cfg.Me.Name = name + return cfg +} + +// Creates a new IRC connection object, but doesn't connect to anything so +// that you can add event handlers to it. See AddHandler() for details +func SimpleClient(nick string, args ...string) (*Conn, error) { + return Client(NewConfig(nick, args...)) +} + +func Client(cfg *Config) (*Conn, error) { + logging.InitFromFlags() + if cfg.Me == nil || cfg.Me.Nick == "" || cfg.Me.Ident == "" { + return nil, fmt.Errorf("Must provide a valid state.Nick in cfg.Me.") + } conn := &Conn{ + Me: cfg.Me, + cfg: cfg, in: make(chan *Line, 32), out: make(chan string, 32), cSend: make(chan bool), @@ -85,17 +113,15 @@ func Client(nick string, args ...string) *Conn { handlers: handlerSet(), commands: commandSet(), stRemovers: make([]Remover, 0, len(stHandlers)), - PingFreq: 3 * time.Minute, - NewNick: func(s string) string { return s + "_" }, lastsent: time.Now(), } conn.addIntHandlers() - conn.Me = state.NewNick(nick) - conn.Me.Ident = ident - conn.Me.Name = name - conn.initialise() - return conn + return conn, nil +} + +func (conn *Conn) Config() *Config { + return conn.cfg } func (conn *Conn) EnableStateTracking() { @@ -142,12 +168,12 @@ func (conn *Conn) Connect(host string, pass ...string) error { conn.Host, host)) } - if conn.SSL { + if conn.cfg.SSL { if !hasPort(host) { host += ":6697" } logging.Info("irc.Connect(): Connecting to %s with SSL.", host) - if s, err := tls.Dial("tcp", host, conn.SSLConfig); err == nil { + if s, err := tls.Dial("tcp", host, conn.cfg.SSLConfig); err == nil { conn.sock = s } else { return err @@ -182,7 +208,7 @@ func (conn *Conn) postConnect() { bufio.NewWriter(conn.sock)) go conn.send() go conn.recv() - if conn.PingFreq > 0 { + if conn.cfg.PingFreq > 0 { go conn.ping() } else { // Otherwise the send in shutdown will hang :-/ @@ -232,7 +258,7 @@ func (conn *Conn) recv() { // Repeatedly pings the server every PingFreq seconds (no matter what) func (conn *Conn) ping() { - tick := time.NewTicker(conn.PingFreq) + tick := time.NewTicker(conn.cfg.PingFreq) for { select { case <-tick.C: @@ -258,9 +284,9 @@ func (conn *Conn) runLoop() { } // Write a \r\n terminated line of output to the connected server, -// using Hybrid's algorithm to rate limit if conn.Flood is false. +// using Hybrid's algorithm to rate limit if conn.cfg.Flood is false. func (conn *Conn) write(line string) { - if !conn.Flood { + if !conn.cfg.Flood { if t := conn.rateLimit(len(line)); t != 0 { // sleep for the current line's time value before sending it logging.Debug("irc.rateLimit(): Flood! Sleeping for %.2f secs.", @@ -303,7 +329,7 @@ func (conn *Conn) rateLimit(chars int) time.Duration { func (conn *Conn) shutdown() { // Guard against double-call of shutdown() if we get an error in send() - // as calling sock.Close() will cause recv() to recieve EOF in readstring() + // as calling sock.Close() will cause recv() to receive EOF in readstring() if conn.Connected { logging.Info("irc.shutdown(): Disconnected from server.") conn.dispatch(&Line{Cmd: "disconnected"}) diff --git a/client/connection_test.go b/client/connection_test.go index f8b5950..471981e 100644 --- a/client/connection_test.go +++ b/client/connection_test.go @@ -21,12 +21,12 @@ func setUp(t *testing.T, start ...bool) (*Conn, *testState) { ctrl := gomock.NewController(t) st := state.NewMockTracker(ctrl) nc := MockNetConn(t) - c := Client("test", "test", "Testing IRC") + c, _ := SimpleClient("test", "test", "Testing IRC") logging.SetLogLevel(logging.LogFatal) c.st = st c.sock = nc - c.Flood = true // Tests can take a while otherwise + c.cfg.Flood = true // Tests can take a while otherwise c.Connected = true if len(start) == 0 { // Hack to allow tests of send, recv, write etc. @@ -82,7 +82,7 @@ func TestEOF(t *testing.T) { func TestClientAndStateTracking(t *testing.T) { ctrl := gomock.NewController(t) st := state.NewMockTracker(ctrl) - c := Client("test", "test", "Testing IRC") + c, _ := SimpleClient("test", "test", "Testing IRC") // Assert some basic things about the initial state of the Conn struct if c.Me.Nick != "test" || c.Me.Ident != "test" || @@ -278,7 +278,7 @@ func TestPing(t *testing.T) { defer s.ctrl.Finish() // Set a low ping frequency for testing. - c.PingFreq = 50 * time.Millisecond + c.cfg.PingFreq = 50 * time.Millisecond // reader is a helper to do a "non-blocking" read of c.out reader := func() string { @@ -429,13 +429,13 @@ func TestWrite(t *testing.T) { c.write("yo momma") s.nc.Expect("yo momma") - // Flood control is disabled -- setUp sets c.Flood = true -- so we should + // Flood control is disabled -- setUp sets c.cfg.Flood = true -- so we should // not have set c.badness at this point. if c.badness != 0 { t.Errorf("Flood control used when Flood = true.") } - c.Flood = false + c.cfg.Flood = false c.write("she so useless") s.nc.Expect("she so useless") diff --git a/client/handlers.go b/client/handlers.go index 6b34977..9829f40 100644 --- a/client/handlers.go +++ b/client/handlers.go @@ -54,7 +54,7 @@ func (conn *Conn) h_001(line *Line) { // Handler to deal with "433 :Nickname already in use" func (conn *Conn) h_433(line *Line) { // Args[1] is the new nick we were attempting to acquire - neu := conn.NewNick(line.Args[1]) + neu := conn.cfg.NewNick(line.Args[1]) conn.Nick(neu) // if this is happening before we're properly connected (i.e. the nick // we sent in the initial NICK command is in use) we will not receive @@ -87,7 +87,7 @@ 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) { + if conn.cfg.CommandStripNick && strings.HasPrefix(txt, conn.Me.Nick) { // Look for '^${nick}[:;>,-]? ' l := len(conn.Me.Nick) switch txt[l] { @@ -102,7 +102,7 @@ func (conn *Conn) h_PRIVMSG(line *Line) { if cmd == nil { return } - if conn.CommandStripPrefix { + if conn.cfg.CommandStripPrefix { txt = strings.TrimSpace(txt[l:]) } if txt != line.Args[1] { diff --git a/client/handlers_test.go b/client/handlers_test.go index 1231bab..f7ae665 100644 --- a/client/handlers_test.go +++ b/client/handlers_test.go @@ -157,26 +157,26 @@ func TestPRIVMSG(t *testing.T) { c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar")) s.nc.ExpectNothing() - c.CommandStripNick = true + c.cfg.CommandStripNick = true c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :prefix bar")) s.nc.Expect("PRIVMSG #foo :prefix bar") c.h_PRIVMSG(parseLine(":blah!moo@cows.com PRIVMSG #foo :test: prefix bar")) s.nc.Expect("PRIVMSG #foo :prefix bar") - c.CommandStripPrefix = true + c.cfg.CommandStripPrefix = 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")) s.nc.Expect("PRIVMSG #foo :bar") - c.CommandStripNick = false + c.cfg.CommandStripNick = false 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")) s.nc.ExpectNothing() // Check the various nick addressing notations that are supported. - c.CommandStripNick = true + c.cfg.CommandStripNick = true for _, addr := range []string{":", ";", ",", ">", "-", ""} { c.h_PRIVMSG(parseLine(fmt.Sprintf( ":blah!moo@cows.com PRIVMSG #foo :test%s prefix bar", addr)))