mirror of https://github.com/fluffle/goirc
Merge remote-tracking branch 'fluffle/master' into commandmerge
Conflicts: README.md client.go client/connection.go client/connection_test.go client/dispatch.go client/dispatch_test.go client/handlers.go client/handlers_test.go
This commit is contained in:
Chris Rhodes
commit
930f29959b
10
README.md
10
README.md
|
|
@ -18,17 +18,25 @@ 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.
|
||||
<<<<<<< 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
|
||||
|
|
|
|||
|
|
@ -3,9 +3,9 @@ package client
|
|||
import "strings"
|
||||
|
||||
const (
|
||||
INIT = "init"
|
||||
CONNECTED = "connected"
|
||||
DISCONNECTED = "disconnected"
|
||||
REGISTER = "REGISTER"
|
||||
CONNECTED = "CONNECTED"
|
||||
DISCONNECTED = "DISCONNECTED"
|
||||
ACTION = "ACTION"
|
||||
AWAY = "AWAY"
|
||||
CTCP = "CTCP"
|
||||
|
|
|
|||
|
|
@ -14,36 +14,46 @@ import (
|
|||
|
||||
// An IRC connection is represented by this struct.
|
||||
type Conn struct {
|
||||
// Connection Hostname and Nickname
|
||||
Host string
|
||||
Me *state.Nick
|
||||
Network string
|
||||
password 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 *handlerSet
|
||||
commands *commandList
|
||||
|
||||
// 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.
|
||||
// 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
|
||||
sock net.Conn
|
||||
io *bufio.ReadWriter
|
||||
in chan *Line
|
||||
out chan string
|
||||
|
||||
// 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
|
||||
|
|
@ -59,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"
|
||||
|
||||
|
|
@ -78,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),
|
||||
|
|
@ -87,46 +113,46 @@ func Client(nick string, args ...string) *Conn {
|
|||
handlers: newHandlerSet(),
|
||||
commands: newCommandList(),
|
||||
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() {
|
||||
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()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -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
|
||||
|
|
@ -165,13 +191,13 @@ func (conn *Conn) Connect(host string, pass ...string) error {
|
|||
}
|
||||
conn.Host = host
|
||||
conn.Connected = true
|
||||
if len(pass) > 0 {
|
||||
conn.password = pass[0]
|
||||
} else {
|
||||
conn.password = ""
|
||||
}
|
||||
conn.postConnect()
|
||||
conn.dispatch(&Line{Cmd: INIT})
|
||||
|
||||
if len(pass) > 0 {
|
||||
conn.Pass(pass[0])
|
||||
}
|
||||
conn.Nick(conn.Me.Nick)
|
||||
conn.User(conn.Me.Ident, conn.Me.Name)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
|
@ -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,11 +258,11 @@ 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:
|
||||
conn.Ping(fmt.Sprintf("%d", time.Now().UnixNano()))
|
||||
conn.Raw(fmt.Sprintf("PING :%d", time.Now().UnixNano()))
|
||||
case <-conn.cPing:
|
||||
tick.Stop()
|
||||
return
|
||||
|
|
@ -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,10 +329,10 @@ 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})
|
||||
conn.dispatch(&Line{Cmd: "disconnected"})
|
||||
conn.Connected = false
|
||||
conn.sock.Close()
|
||||
conn.cSend <- true
|
||||
|
|
@ -329,8 +355,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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,22 +12,21 @@ 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")
|
||||
c, _ := SimpleClient("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.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.
|
||||
|
|
@ -83,8 +82,8 @@ func TestEOF(t *testing.T) {
|
|||
|
||||
func TestClientAndStateTracking(t *testing.T) {
|
||||
ctrl := gomock.NewController(t)
|
||||
st := state.NewMockStateTracker(ctrl)
|
||||
c := Client("test", "test", "Testing IRC")
|
||||
st := state.NewMockTracker(ctrl)
|
||||
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" ||
|
||||
|
|
@ -115,16 +114,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.")
|
||||
}
|
||||
|
||||
|
|
@ -280,7 +279,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 {
|
||||
|
|
@ -431,13 +430,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")
|
||||
|
||||
|
|
|
|||
|
|
@ -185,7 +185,7 @@ var SimpleCommandRegex string = `^!%v(\s|$)`
|
|||
func (conn *Conn) SimpleCommand(prefix string, handler Handler) Remover {
|
||||
stripHandler := func(conn *Conn, line *Line) {
|
||||
text := line.Message()
|
||||
if conn.SimpleCommandStripPrefix {
|
||||
if conn.cfg.SimpleCommandStripPrefix {
|
||||
text = strings.TrimSpace(text[len(prefix):])
|
||||
}
|
||||
if text != line.Message() {
|
||||
|
|
|
|||
|
|
@ -9,13 +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,
|
||||
PRIVMSG: (*Conn).h_PRIVMSG,
|
||||
REGISTER: (*Conn).h_REGISTER,
|
||||
"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() {
|
||||
|
|
@ -26,20 +26,20 @@ 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.Pong(line.Args[0])
|
||||
}
|
||||
|
||||
// Handler for initial registration with server once tcp connection is made.
|
||||
func (conn *Conn) h_REGISTER(line *Line) {
|
||||
if conn.cfg.Pass != "" {
|
||||
conn.Pass(conn.cfg.Pass)
|
||||
}
|
||||
conn.Nick(conn.cfg.Me.Nick)
|
||||
conn.User(conn.cfg.Me.Ident, conn.cfg.Me.Name)
|
||||
}
|
||||
|
||||
// Handler to trigger a "CONNECTED" event on receipt of numeric 001
|
||||
func (conn *Conn) h_001(line *Line) {
|
||||
// we're connected!
|
||||
|
|
@ -65,14 +65,14 @@ 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
|
||||
// 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
|
||||
}
|
||||
|
|
@ -90,15 +90,15 @@ 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 {
|
||||
conn.Me.Nick = line.Args[0]
|
||||
if conn.st == nil && line.Nick == conn.cfg.Me.Nick {
|
||||
conn.cfg.Me.Nick = line.Args[0]
|
||||
}
|
||||
}
|
||||
|
||||
// Handle PRIVMSGs that trigger Commands
|
||||
func (conn *Conn) h_PRIVMSG(line *Line) {
|
||||
text := line.Message()
|
||||
if conn.CommandStripNick && strings.HasPrefix(text, conn.Me.Nick) {
|
||||
if conn.cfg.CommandStripNick && strings.HasPrefix(text, conn.Me.Nick) {
|
||||
// Look for '^${nick}[:;>,-]? '
|
||||
l := len(conn.Me.Nick)
|
||||
switch text[l] {
|
||||
|
|
|
|||
|
|
@ -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).
|
||||
|
|
@ -159,26 +159,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.SimpleCommandStripPrefix = true
|
||||
c.cfg.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"))
|
||||
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)))
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
Loading…
Reference in New Issue