Merge pull request #31 from edmund-huber/theater_mode_cleanup

clean up /theater

irc/channel.go

 )
 
 type Channel struct {
-	flags       ChannelModeSet
-	lists       map[ChannelMode]*UserMaskSet
-	key         Text
-	members     MemberSet
-	name        Name
-	server      *Server
-	topic       Text
-	userLimit   uint64
-	theaterUser *Client
+	flags     ChannelModeSet
+	lists     map[ChannelMode]*UserMaskSet
+	key       Text
+	members   MemberSet
+	name      Name
+	server    *Server
+	topic     Text
+	userLimit uint64
 }
 
 // NewChannel creates a new channel from a `Server` and a `name`
 		return channel.applyModeMember(client, change.mode, change.op,
 			NewName(change.arg))
 
-	case Theater:
-		client.ErrConfiguredMode(change.mode)
-
 	default:
 		client.ErrUnknownMode(change.mode, channel)
 	}

irc/client.go

 )
 
 type Client struct {
-	atime           time.Time
-	authorized      bool
-	awayMessage     Text
-	capabilities    CapabilitySet
-	capState        CapState
-	channels        ChannelSet
-	commands        chan Command
-	ctime           time.Time
-	flags           map[UserMode]bool
-	hasQuit         bool
-	hops            uint
-	hostname        Name
-	idleTimer       *time.Timer
-	loginTimer      *time.Timer
-	nick            Name
-	quitTimer       *time.Timer
-	realname        Text
-	registered      bool
-	server          *Server
-	socket          *Socket
-	username        Name
-	theaterChannels []*Channel
+	atime        time.Time
+	authorized   bool
+	awayMessage  Text
+	capabilities CapabilitySet
+	capState     CapState
+	channels     ChannelSet
+	commands     chan Command
+	ctime        time.Time
+	flags        map[UserMode]bool
+	hasQuit      bool
+	hops         uint
+	hostname     Name
+	idleTimer    *time.Timer
+	loginTimer   *time.Timer
+	nick         Name
+	quitTimer    *time.Timer
+	realname     Text
+	registered   bool
+	server       *Server
+	socket       *Socket
+	username     Name
 }
 
 func NewClient(server *Server, conn net.Conn) *Client {
 		return
 	}
 
-	for _, channel := range client.theaterChannels {
-		delete(channel.flags, Theater)
-	}
-
 	client.Reply(RplError("connection closed"))
 	client.hasQuit = true
 	client.server.whoWas.Append(client)

irc/commands.go

 		return &TheaterActionCommand{
 			channel: NewName(args[1]),
 			asNick:  NewName(args[2]),
-			action:  NewText(args[3]),
+			action:  NewCTCPText(args[3]),
 		}, nil
 	} else {
 		return nil, ErrParseCommand

irc/modes.go

 	Quiet           ChannelMode = 'q' // flag
 	ReOp            ChannelMode = 'r' // flag
 	Secret          ChannelMode = 's' // flag, deprecated
-	Theater         ChannelMode = 'T' // flag arg, nonstandard
+	Theater         ChannelMode = 'T' // flag, nonstandard
 	UserLimit       ChannelMode = 'l' // flag arg
 	Voice           ChannelMode = 'v' // arg
 )

irc/reply.go

 	return NewStringReply(source, PRIVMSG, "%s :%s", target.Nick(), message)
 }
 
+func RplCTCPAction(source Identifiable, target Identifiable, action CTCPText) string {
+	return RplPrivMsg(source, target, NewText(fmt.Sprintf("\x01ACTION %s\x01", action)))
+}
+
 func RplNotice(source Identifiable, target Identifiable, message Text) string {
 	return NewStringReply(source, NOTICE, "%s :%s", target.Nick(), message)
 }

irc/strings.go

 func (text Text) String() string {
 	return string(text)
 }
+
+// CTCPText is text suitably escaped for CTCP.
+type CTCPText string
+
+var ctcpEscaper = strings.NewReplacer("\x00", "\x200", "\n", "\x20n", "\r", "\x20r")
+
+func NewCTCPText(str string) CTCPText {
+	return CTCPText(ctcpEscaper.Replace(str))
+}

irc/theater.go

 		return
 	}
 
-	if channel.theaterUser == nil {
-		client.theaterChannels = append(client.theaterChannels, channel)
-		channel.flags[Theater] = true
-		channel.theaterUser = client
+	if channel.members.AnyHasMode(Theater) {
+		client.Reply(RplNotice(s, client, "someone else is +T in this channel"))
+		return
 	}
+
+	channel.members[client][Theater] = true
 }
 
 type TheaterPrivMsgCommand struct {
 }
 func (m *TheaterPrivMsgCommand) HandleServer(s *Server) {
 	client := m.Client()
+
 	if !m.channel.IsChannel() {
 		client.ErrNoSuchChannel(m.channel)
 		return
 		return
 	}
 
-	if channel.theaterUser == client {
-		for member := range channel.members {
-			member.Reply(RplPrivMsg(TheaterClient(m.asNick), channel, m.message))
-		}
+	if !channel.members.HasMode(client, Theater) {
+		client.Reply(RplNotice(s, client, "you are not +T"))
+		return
+	}
+
+	for member := range channel.members {
+		member.Reply(RplPrivMsg(TheaterClient(m.asNick), channel, m.message))
 	}
 }
 
 	BaseCommand
 	channel Name
 	asNick  Name
-	action  Text
+	action  CTCPText
 }
 
 func (cmd *TheaterActionCommand) String() string {
 
 func (m *TheaterActionCommand) HandleServer(s *Server) {
 	client := m.Client()
-	if m.channel.IsChannel() {
+
+	if !m.channel.IsChannel() {
 		client.ErrNoSuchChannel(m.channel)
 		return
 	}
 		return
 	}
 
-	if channel.theaterUser == client {
-		for member := range channel.members {
-			member.Reply(RplPrivMsg(TheaterClient(m.asNick), channel, NewText(fmt.Sprintf("\001ACTION %s\001", m.action))))
-		}
+	if !channel.members.HasMode(client, Theater) {
+		client.Reply(RplNotice(s, client, "you are not +T"))
+		return
+	}
+
+	for member := range channel.members {
+		member.Reply(RplCTCPAction(TheaterClient(m.asNick), channel, m.action))
 	}
 }

irc/types.go

 	return modes[mode]
 }
 
+func (members MemberSet) AnyHasMode(mode ChannelMode) bool {
+	for _, modes := range members {
+		if modes[mode] {
+			return true
+		}
+	}
+	return false
+}
+
 type ChannelSet map[*Channel]bool
 
 func (channels ChannelSet) Add(channel *Channel) {