Misc refactoring

irc/capability.go

-// Copyright (c) 2012-2014 Jeremy Latt
-// Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
-// released under the MIT license
-
-package irc
-
-import (
-	"github.com/oragono/oragono/irc/caps"
-)
-
-var (
-	// SupportedCapabilities are the caps we advertise.
-	// MaxLine, SASL and STS are set during server startup.
-	SupportedCapabilities = caps.NewSet(caps.AccountTag, caps.AccountNotify, caps.AwayNotify, caps.CapNotify, caps.ChgHost, caps.EchoMessage, caps.ExtendedJoin, caps.InviteNotify, caps.Languages, caps.MessageTags, caps.MultiPrefix, caps.Rename, caps.Resume, caps.ServerTime, caps.UserhostInNames)
-
-	// CapValues are the actual values we advertise to v3.2 clients.
-	// actual values are set during server startup.
-	CapValues = caps.NewValues()
-)
-
-// CapState shows whether we're negotiating caps, finished, etc for connection registration.
-type CapState uint
-
-const (
-	// CapNone means CAP hasn't been negotiated at all.
-	CapNone CapState = iota
-	// CapNegotiating means CAP is being negotiated and registration should be paused.
-	CapNegotiating CapState = iota
-	// CapNegotiated means CAP negotiation has been successfully ended and reg should complete.
-	CapNegotiated CapState = iota
-)

irc/caps/constants.go

 	// Cap302 refers to the IRCv3.2 CAP spec.
 	Cap302 Version = 302
 )
+
+// State shows whether we're negotiating caps, finished, etc for connection registration.
+type State uint
+
+const (
+	// NoneState means CAP hasn't been negotiated at all.
+	NoneState State = iota
+	// NegotiatingState means CAP is being negotiated and registration should be paused.
+	NegotiatingState State = iota
+	// NegotiatedState means CAP negotiation has been successfully ended and reg should complete.
+	NegotiatedState State = iota
+)

irc/channelreg.go

 	Invitelist []string
 }
 
+// ChannelRegistry manages registered channels.
 type ChannelRegistry struct {
-	// this serializes operations of the form (read channel state, synchronously persist it);
+	// This serializes operations of the form (read channel state, synchronously persist it);
 	// this is enough to guarantee eventual consistency of the database with the
 	// ChannelManager and Channel objects, which are the source of truth.
-	// Wwe could use the buntdb RW transaction lock for this purpose but we share
+	//
+	// We could use the buntdb RW transaction lock for this purpose but we share
 	// that with all the other modules, so let's not.
 	sync.Mutex // tier 2
 	server     *Server
 }
 
+// NewChannelRegistry returns a new ChannelRegistry.
 func NewChannelRegistry(server *Server) *ChannelRegistry {
 	return &ChannelRegistry{
 		server: server,

irc/chanserv.go

 	"github.com/oragono/oragono/irc/sno"
 )
 
-func (server *Server) chanservReceiveNotice(client *Client, message string) {
-	// do nothing
-}
-
 // ChanServNotice sends the client a notice from ChanServ.
 func (client *Client) ChanServNotice(text string) {
 	client.Send(nil, fmt.Sprintf("ChanServ!services@%s", client.server.name), "NOTICE", client.nick, text)
 }
 
-func (server *Server) chanservReceivePrivmsg(client *Client, message string) {
+// chanservReceiveNotice handles NOTICEs that ChanServ receives.
+func (server *Server) chanservNoticeHandler(client *Client, message string) {
+	// do nothing
+}
+
+// chanservReceiveNotice handles NOTICEs that ChanServ receives.
+func (server *Server) chanservPrivmsgHandler(client *Client, message string) {
 	var params []string
 	for _, p := range strings.Split(message, " ") {
 		if len(p) > 0 {

irc/client.go

 	authorized         bool
 	awayMessage        string
 	capabilities       *caps.Set
-	capState           CapState
+	capState           caps.State
 	capVersion         caps.Version
 	certfp             string
 	channels           ChannelSet
 		atime:          now,
 		authorized:     server.Password() == nil,
 		capabilities:   caps.NewSet(),
-		capState:       CapNone,
+		capState:       caps.NoneState,
 		capVersion:     caps.Cap301,
 		channels:       make(ChannelSet),
 		ctime:          now,

irc/handlers.go

 	switch subCommand {
 	case "LS":
 		if !client.registered {
-			client.capState = CapNegotiating
+			client.capState = caps.NegotiatingState
 		}
 		if len(msg.Params) > 1 && msg.Params[1] == "302" {
 			client.capVersion = 302
 
 	case "REQ":
 		if !client.registered {
-			client.capState = CapNegotiating
+			client.capState = caps.NegotiatingState
 		}
 
 		// make sure all capabilities actually exist
 
 	case "END":
 		if !client.registered {
-			client.capState = CapNegotiated
+			client.capState = caps.NegotiatedState
 			server.tryRegister(client)
 		}
 
 
 // csHandler handles the /CS and /CHANSERV commands
 func csHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	server.chanservReceivePrivmsg(client, strings.Join(msg.Params, " "))
+	server.chanservPrivmsgHandler(client, strings.Join(msg.Params, " "))
 	return false
 }
 
 
 // NOTICE <target>{,<target>} <message>
 func noticeHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	clientOnlyTags := GetClientOnlyTags(msg.Tags)
+	clientOnlyTags := utils.GetClientOnlyTags(msg.Tags)
 	targets := strings.Split(msg.Params[0], ",")
 	message := msg.Params[1]
 
 				continue
 			}
 			if target == "chanserv" {
-				server.chanservReceiveNotice(client, message)
+				server.chanservNoticeHandler(client, message)
 				continue
 			} else if target == "nickserv" {
-				server.nickservReceiveNotice(client, message)
+				server.nickservNoticeHandler(client, message)
 				continue
 			}
 
 
 // nsHandler handles the /NS and /NICKSERV commands
 func nsHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	server.nickservReceivePrivmsg(client, strings.Join(msg.Params, " "))
+	server.nickservPrivmsgHandler(client, strings.Join(msg.Params, " "))
 	return false
 }
 
 
 // PRIVMSG <target>{,<target>} <message>
 func privmsgHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	clientOnlyTags := GetClientOnlyTags(msg.Tags)
+	clientOnlyTags := utils.GetClientOnlyTags(msg.Tags)
 	targets := strings.Split(msg.Params[0], ",")
 	message := msg.Params[1]
 
 		} else {
 			target, err = CasefoldName(targetString)
 			if target == "chanserv" {
-				server.chanservReceivePrivmsg(client, message)
+				server.chanservPrivmsgHandler(client, message)
 				continue
 			} else if target == "nickserv" {
-				server.nickservReceivePrivmsg(client, message)
+				server.nickservPrivmsgHandler(client, message)
 				continue
 			}
 			user := server.clients.Get(target)
 
 // TAGMSG <target>{,<target>}
 func tagmsgHandler(server *Server, client *Client, msg ircmsg.IrcMessage) bool {
-	clientOnlyTags := GetClientOnlyTags(msg.Tags)
+	clientOnlyTags := utils.GetClientOnlyTags(msg.Tags)
 	// no client-only tags, so we can drop it
 	if clientOnlyTags == nil {
 		return false

irc/nickserv.go

 Leave out [username password] to use your client certificate fingerprint. Otherwise,
 the given username and password will be used.`
 
-func (server *Server) nickservReceiveNotice(client *Client, message string) {
-	// do nothing
-}
-
 // extractParam extracts a parameter from the given string, returning the param and the rest of the string.
 func extractParam(line string) (string, string) {
 	rawParams := strings.SplitN(strings.TrimSpace(line), " ", 2)
 	return param0, param1
 }
 
-func (server *Server) nickservReceivePrivmsg(client *Client, message string) {
+// nickservNoticeHandler handles NOTICEs that NickServ receives.
+func (server *Server) nickservNoticeHandler(client *Client, message string) {
+	// do nothing
+}
+
+// nickservPrivmsgHandler handles PRIVMSGs that NickServ receives.
+func (server *Server) nickservPrivmsgHandler(client *Client, message string) {
 	command, params := extractParam(message)
 	command = strings.ToLower(command)
 

irc/server.go

 	supportedUserModesString = modes.SupportedUserModes.String()
 	// supportedChannelModesString acts as a cache for when we introduce users
 	supportedChannelModesString = modes.SupportedChannelModes.String()
+
+	// SupportedCapabilities are the caps we advertise.
+	// MaxLine, SASL and STS are set during server startup.
+	SupportedCapabilities = caps.NewSet(caps.AccountTag, caps.AccountNotify, caps.AwayNotify, caps.CapNotify, caps.ChgHost, caps.EchoMessage, caps.ExtendedJoin, caps.InviteNotify, caps.Languages, caps.MessageTags, caps.MultiPrefix, caps.Rename, caps.Resume, caps.ServerTime, caps.UserhostInNames)
+
+	// CapValues are the actual values we advertise to v3.2 clients.
+	// actual values are set during server startup.
+	CapValues = caps.NewValues()
 )
 
 // Limits holds the maximum limits for various things such as topic lengths.
 
 func (server *Server) tryRegister(c *Client) {
 	if c.registered || !c.HasNick() || !c.HasUsername() ||
-		(c.capState == CapNegotiating) {
+		(c.capState == caps.NegotiatingState) {
 		return
 	}
 

irc/message_tags.go → irc/utils/message_tags.go

 // Copyright (c) 2016-2017 Daniel Oaks <daniel@danieloaks.net>
 // released under the MIT license
 
-package irc
+package utils
 
 import "github.com/goshuirc/irc-go/ircmsg"