babbler: refactor

bot/bot.go

@@ -230,6 +230,17 @@ func (b *bot) RegisterFilter(name string, f func(string) string) {
 	b.filters[name] = f
 }
 
+// RegisterTable registers multiple regex handlers at a time
+func (b *bot) RegisterTable(p Plugin, handlers HandlerTable) {
+	for _, h := range handlers {
+		if h.IsCmd {
+			b.RegisterRegexCmd(p, h.Kind, h.Regex, h.Handler)
+		} else {
+			b.RegisterRegex(p, h.Kind, h.Regex, h.Handler)
+		}
+	}
+}
+
 // RegisterRegex does what register does, but with a matcher
 func (b *bot) RegisterRegex(p Plugin, kind Kind, r *regexp.Regexp, resp ResponseHandler) {
 	t := reflect.TypeOf(p).String()

bot/handlers.go

@@ -57,15 +57,15 @@ func (b *bot) runCallback(conn Connector, plugin Plugin, evt Kind, message msg.M
 	t := reflect.TypeOf(plugin).String()
 	for r, cbs := range b.callbacks[t][evt] {
 		if r.MatchString(message.Body) {
-			for _, cb := range cbs {
-				resp := Request{
+			req := Request{
 				Conn:   conn,
 				Kind:   evt,
 				Msg:    message,
 				Values: ParseValues(r, message.Body),
 				Args:   args,
 			}
-				if cb(resp) {
+			for _, cb := range cbs {
+				if cb(req) {
 					return true
 				}
 			}

bot/interfaces.go

@@ -61,6 +61,14 @@ type Callback func(Connector, Kind, msg.Message, ...interface{}) bool
 type ResponseHandler func(Request) bool
 type CallbackMap map[string]map[Kind]map[*regexp.Regexp][]ResponseHandler
 
+type HandlerSpec struct {
+	Kind    Kind
+	IsCmd   bool
+	Regex   *regexp.Regexp
+	Handler ResponseHandler
+}
+type HandlerTable []HandlerSpec
+
 type RegexValues map[string]string
 
 // b interface serves to allow mocking of the actual bot
@@ -90,6 +98,10 @@ type Bot interface {
 	// The Kind arg should be one of bot.Message/Reply/Action/etc
 	Receive(Connector, Kind, msg.Message, ...interface{}) bool
 
+	// Register a set of plugin callbacks
+	// Kind will be matched to the event for the callback
+	RegisterTable(Plugin, HandlerTable)
+
 	// Register a plugin callback
 	// Kind will be matched to the event for the callback
 	RegisterRegex(Plugin, Kind, *regexp.Regexp, ResponseHandler)

bot/mock.go

@@ -54,6 +54,7 @@ func (mb *MockBot) Send(c Connector, kind Kind, args ...interface{}) (string, er
 }
 func (mb *MockBot) AddPlugin(f Plugin)                                                        {}
 func (mb *MockBot) Register(p Plugin, kind Kind, cb Callback)                                 {}
+func (mb *MockBot) RegisterTable(p Plugin, hs HandlerTable)                                   {}
 func (mb *MockBot) RegisterRegex(p Plugin, kind Kind, r *regexp.Regexp, h ResponseHandler)    {}
 func (mb *MockBot) RegisterRegexCmd(p Plugin, kind Kind, r *regexp.Regexp, h ResponseHandler) {}
 func (mb *MockBot) RegisterWeb(_, _ string)                                                   {}

plugins/admin/admin.go

@@ -30,16 +30,37 @@ type AdminPlugin struct {
 	quiet bool
 }
 
-// NewAdminPlugin creates a new AdminPlugin with the Plugin interface
+// New creates a new AdminPlugin with the Plugin interface
 func New(b bot.Bot) *AdminPlugin {
 	p := &AdminPlugin{
 		bot: b,
 		db:  b.DB(),
 		cfg: b.Config(),
 	}
-	b.Register(p, bot.Message, p.message)
+
+	b.RegisterRegex(p, bot.Message, comeBackRegex, p.comeBackCmd)
+	b.RegisterRegexCmd(p, bot.Message, shutupRegex, p.shutupCmd)
+	b.RegisterRegexCmd(p, bot.Message, addBlacklistRegex, p.isAdmin(p.addBlacklistCmd))
+	b.RegisterRegexCmd(p, bot.Message, rmBlacklistRegex, p.isAdmin(p.rmBlacklistCmd))
+	b.RegisterRegexCmd(p, bot.Message, addWhitelistRegex, p.isAdmin(p.addWhitelistCmd))
+	b.RegisterRegexCmd(p, bot.Message, rmWhitelistRegex, p.isAdmin(p.rmWhitelistCmd))
+	b.RegisterRegexCmd(p, bot.Message, allWhitelistRegex, p.isAdmin(p.allWhitelistCmd))
+	b.RegisterRegexCmd(p, bot.Message, allUnWhitelistRegex, p.isAdmin(p.allUnWhitelistCmd))
+	b.RegisterRegexCmd(p, bot.Message, getWhitelistRegex, p.isAdmin(p.getWhitelistCmd))
+	b.RegisterRegexCmd(p, bot.Message, getPluginsRegex, p.isAdmin(p.getPluginsCmd))
+	b.RegisterRegexCmd(p, bot.Message, rebootRegex, p.isAdmin(p.rebootCmd))
+	b.RegisterRegexCmd(p, bot.Message, passwordRegex, p.passwordCmd)
+	b.RegisterRegex(p, bot.Message, variableSetRegex, p.variableSetCmd)
+	b.RegisterRegex(p, bot.Message, variableUnSetRegex, p.variableUnSetCmd)
+	b.RegisterRegexCmd(p, bot.Message, unsetConfigRegex, p.isAdmin(p.unsetConfigCmd))
+	b.RegisterRegexCmd(p, bot.Message, setConfigRegex, p.isAdmin(p.setConfigCmd))
+	b.RegisterRegexCmd(p, bot.Message, pushConfigRegex, p.isAdmin(p.pushConfigCmd))
+	b.RegisterRegexCmd(p, bot.Message, setKeyConfigRegex, p.isAdmin(p.setKeyConfigCmd))
+	b.RegisterRegexCmd(p, bot.Message, getConfigRegex, p.isAdmin(p.getConfigCmd))
+
 	b.Register(p, bot.Help, p.help)
 	p.registerWeb()
+
 	return p
 }
 
@@ -51,47 +72,46 @@ var forbiddenKeys = map[string]bool{
 	"meme.memes":           true,
 }
 
-var addBlacklist = regexp.MustCompile(`(?i)disable plugin (.*)`)
-var rmBlacklist = regexp.MustCompile(`(?i)enable plugin (.*)`)
+var shutupRegex = regexp.MustCompile(`(?i)^shut up$`)
+var comeBackRegex = regexp.MustCompile(`(?i)^come back$`)
 
-var addWhitelist = regexp.MustCompile(`(?i)^whitelist plugin (.*)`)
-var rmWhitelist = regexp.MustCompile(`(?i)^unwhitelist plugin (.*)`)
-var allWhitelist = regexp.MustCompile(`(?i)^whitelist all`)
-var allUnwhitelist = regexp.MustCompile(`(?i)^unwhitelist all`)
-var getWhitelist = regexp.MustCompile(`(?i)^list whitelist`)
-var getPlugins = regexp.MustCompile(`(?i)^list plugins`)
+var addBlacklistRegex = regexp.MustCompile(`(?i)disable plugin (?P<plugin>.*)$`)
+var rmBlacklistRegex = regexp.MustCompile(`(?i)enable plugin (?P<plugin>.*)$`)
 
-// Message responds to the bot hook on recieving messages.
-// This function returns true if the plugin responds in a meaningful way to the users message.
-// Otherwise, the function returns false and the bot continues execution of other plugins.
-func (p *AdminPlugin) message(conn bot.Connector, k bot.Kind, message msg.Message, args ...interface{}) bool {
-	body := message.Body
+var addWhitelistRegex = regexp.MustCompile(`(?i)^whitelist plugin (?P<plugin>.*)$`)
+var rmWhitelistRegex = regexp.MustCompile(`(?i)^unwhitelist plugin (?P<plugin>.*)$`)
+var allWhitelistRegex = regexp.MustCompile(`(?i)^whitelist all$`)
+var allUnWhitelistRegex = regexp.MustCompile(`(?i)^unwhitelist all$`)
+var getWhitelistRegex = regexp.MustCompile(`(?i)^list whitelist$`)
+var getPluginsRegex = regexp.MustCompile(`(?i)^list plugins$`)
 
-	if p.quiet && message.Body != "come back" {
-		return true
-	}
+var rebootRegex = regexp.MustCompile(`^reboot$`)
+var passwordRegex = regexp.MustCompile(`(?i)^password$`)
 
-	if len(body) > 0 && body[0] == '$' {
-		return p.handleVariables(conn, message)
-	}
+var variableSetRegex = regexp.MustCompile(`(?i)^\$(?P<var>\S+)\s?=\s?(?P<value>\S+)$`)
+var variableUnSetRegex = regexp.MustCompile(`(?i)^\$(?P<var>\S+)\s?!=\s?(?P<value>\S+)$`)
 
-	if !message.Command {
+var unsetConfigRegex = regexp.MustCompile(`(?i)^unset (?P<key>\S+)$`)
+var setConfigRegex = regexp.MustCompile(`(?i)^set (?P<key>\S+) (?P<value>.*)$`)
+var pushConfigRegex = regexp.MustCompile(`(?i)^push (?P<key>\S+) (?P<value>.*)$`)
+var setKeyConfigRegex = regexp.MustCompile(`(?i)^setkey (?P<key>\S+) (?P<name>\S+) (?P<value>.*)$`)
+var getConfigRegex = regexp.MustCompile(`(?i)^get (?P<key>\S+)$`)
+
+func (p *AdminPlugin) isAdmin(rh bot.ResponseHandler) bot.ResponseHandler {
+	return func(r bot.Request) bool {
+		if !p.bot.CheckAdmin(r.Msg.User.Name) {
+			log.Debug().Msgf("User %s is not an admin", r.Msg.User.Name)
 			return false
 		}
-
-	if p.quiet && message.Body == "come back" {
-		p.quiet = false
-		p.bot.SetQuiet(false)
-		backMsg := p.bot.Config().Get("admin.comeback", "Okay, I'm back.")
-		p.bot.Send(conn, bot.Message, message.Channel, backMsg)
-		return true
+		return rh(r)
+	}
 }
 
-	if strings.ToLower(body) == "shut up" {
+func (p *AdminPlugin) shutupCmd(r bot.Request) bool {
 	dur := time.Duration(p.cfg.GetInt("quietDuration", 5)) * time.Minute
 	log.Info().Msgf("Going to sleep for %v, %v", dur, time.Now().Add(dur))
 	leaveMsg := p.bot.Config().Get("admin.shutup", "Okay. I'll be back later.")
-		p.bot.Send(conn, bot.Message, message.Channel, leaveMsg)
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, leaveMsg)
 	p.quiet = true
 	p.bot.SetQuiet(true)
 	go func() {
@@ -101,220 +121,230 @@ func (p *AdminPlugin) message(conn bot.Connector, k bot.Kind, message msg.Messag
 			p.bot.SetQuiet(false)
 			log.Info().Msg("Waking up from nap.")
 			backMsg := p.bot.Config().Get("admin.backmsg", "I'm back, bitches.")
-				p.bot.Send(conn, bot.Message, message.Channel, backMsg)
+			p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, backMsg)
 		}
 	}()
 	return true
 }
 
-	if !p.bot.CheckAdmin(message.User.Name) {
-		log.Debug().Msgf("User %s is not an admin", message.User.Name)
-		return false
+func (p *AdminPlugin) comeBackCmd(r bot.Request) bool {
+	p.quiet = false
+	p.bot.SetQuiet(false)
+	backMsg := p.bot.Config().Get("admin.comeback", "Okay, I'm back.")
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, backMsg)
+	return true
 }
 
-	if strings.ToLower(body) == "reboot" {
-		p.bot.Send(conn, bot.Message, message.Channel, "brb")
-		log.Info().Msgf("Got reboot command")
-		os.Exit(0)
-	}
-
-	if addBlacklist.MatchString(body) {
-		submatches := addBlacklist.FindStringSubmatch(message.Body)
-		plugin := submatches[1]
-		if err := p.addBlacklist(message.Channel, plugin); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't add that item: %s", err))
+func (p *AdminPlugin) addBlacklistCmd(r bot.Request) bool {
+	plugin := r.Values["plugin"]
+	if err := p.addBlacklist(r.Msg.Channel, plugin); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't add that item: %s", err))
 		log.Error().Err(err).Msgf("error adding blacklist item")
 		return true
 	}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("%s disabled. Use `!enable plugin %s` to re-enable it.", plugin, plugin))
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("%s disabled. Use `!enable plugin %s` to re-enable it.", plugin, plugin))
 	return true
 }
 
-	if rmBlacklist.MatchString(body) {
-		submatches := rmBlacklist.FindStringSubmatch(message.Body)
-		plugin := submatches[1]
-		if err := p.rmBlacklist(message.Channel, plugin); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't remove that item: %s", err))
+func (p *AdminPlugin) rmBlacklistCmd(r bot.Request) bool {
+	plugin := r.Values["plugin"]
+	if err := p.rmBlacklist(r.Msg.Channel, plugin); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't remove that item: %s", err))
 		log.Error().Err(err).Msgf("error removing blacklist item")
 		return true
 	}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("%s enabled. Use `!disable plugin %s` to disable it.", plugin, plugin))
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("%s enabled. Use `!disable plugin %s` to disable it.", plugin, plugin))
 	return true
 }
 
-	if allWhitelist.MatchString(body) {
+func (p *AdminPlugin) addWhitelistCmd(r bot.Request) bool {
+	plugin := r.Values["plugin"]
+	if err := p.addWhitelist(plugin); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't whitelist that item: %s", err))
+		log.Error().Err(err).Msgf("error adding whitelist item")
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("%s enabled. Use `!unwhitelist plugin %s` to disable it.", plugin, plugin))
+	return true
+}
+
+func (p *AdminPlugin) rmWhitelistCmd(r bot.Request) bool {
+	plugin := r.Values["plugin"]
+	if err := p.rmWhitelist(plugin); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't unwhitelist that item: %s", err))
+		log.Error().Err(err).Msgf("error removing whitelist item")
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("%s disabled. Use `!whitelist plugin %s` to enable it.", plugin, plugin))
+	return true
+}
+
+func (p *AdminPlugin) allWhitelistCmd(r bot.Request) bool {
 	plugins := p.bot.GetPluginNames()
 	for _, plugin := range plugins {
 		if err := p.addWhitelist(plugin); err != nil {
-				p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't whitelist that item: %s", err))
+			p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't whitelist that item: %s", err))
 			log.Error().Err(err).Msgf("error adding whitelist item")
 			return true
 		}
 	}
-		p.bot.Send(conn, bot.Message, message.Channel, "Enabled all plugins")
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "Enabled all plugins")
 	return true
 }
 
-	if allUnwhitelist.MatchString(body) {
+func (p *AdminPlugin) allUnWhitelistCmd(r bot.Request) bool {
 	plugins := p.bot.GetPluginNames()
 	for _, plugin := range plugins {
 		if plugin == "admin" {
 			continue
 		}
 		if err := p.rmWhitelist(plugin); err != nil {
-				p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't unwhitelist that item: %s", err))
+			p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("I couldn't unwhitelist that item: %s", err))
 			log.Error().Err(err).Msgf("error removing whitelist item")
 			return true
 		}
 	}
-		p.bot.Send(conn, bot.Message, message.Channel, "Disabled all plugins")
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "Disabled all plugins")
 	return true
 }
 
-	if addWhitelist.MatchString(body) {
-		submatches := addWhitelist.FindStringSubmatch(message.Body)
-		plugin := submatches[1]
-		if err := p.addWhitelist(plugin); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't whitelist that item: %s", err))
-			log.Error().Err(err).Msgf("error adding whitelist item")
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("%s enabled. Use `!unwhitelist plugin %s` to disable it.", plugin, plugin))
-		return true
-	}
-
-	if rmWhitelist.MatchString(body) {
-		submatches := rmWhitelist.FindStringSubmatch(message.Body)
-		plugin := submatches[1]
-		if err := p.rmWhitelist(plugin); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("I couldn't unwhitelist that item: %s", err))
-			log.Error().Err(err).Msgf("error removing whitelist item")
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("%s disabled. Use `!whitelist plugin %s` to enable it.", plugin, plugin))
-		return true
-	}
-
-	if getWhitelist.MatchString(body) {
+func (p *AdminPlugin) getWhitelistCmd(r bot.Request) bool {
 	list := p.bot.GetWhitelist()
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Whitelist: %v", list))
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Whitelist: %v", list))
 	return true
 }
 
-	if getPlugins.MatchString(body) {
+func (p *AdminPlugin) getPluginsCmd(r bot.Request) bool {
 	plugins := p.bot.GetPluginNames()
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Plugins: %v", plugins))
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Plugins: %v", plugins))
 	return true
 }
 
-	if strings.ToLower(body) == "password" {
-		p.bot.Send(conn, bot.Message, message.Channel, p.bot.GetPassword())
+func (p *AdminPlugin) rebootCmd(r bot.Request) bool {
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "brb")
+	log.Info().Msgf("Got reboot command")
+	os.Exit(0)
 	return true
 }
 
-	verbs := map[string]bool{
-		"set":    true,
-		"push":   true,
-		"setkey": true,
-	}
-
-	parts := strings.Split(body, " ")
-	if verbs[parts[0]] && len(parts) > 2 && forbiddenKeys[parts[1]] {
-		p.bot.Send(conn, bot.Message, message.Channel, "You cannot access that key")
-		return true
-	} else if parts[0] == "unset" && len(parts) > 1 {
-		if err := p.cfg.Unset(parts[1]); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Unset error: %s", err))
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Unset %s", parts[1]))
-		return true
-	} else if parts[0] == "set" && len(parts) > 2 {
-		if err := p.cfg.Set(parts[1], strings.Join(parts[2:], " ")); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set error: %s", err))
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set %s", parts[1]))
-		return true
-	} else if parts[0] == "push" && len(parts) > 2 {
-		items := p.cfg.GetArray(parts[1], []string{})
-		items = append(items, strings.Join(parts[2:], ""))
-		if err := p.cfg.Set(parts[1], strings.Join(items, ";;")); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set error: %s", err))
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set %s", parts[1]))
-		return true
-	} else if parts[0] == "setkey" && len(parts) > 3 {
-		items := p.cfg.GetMap(parts[1], map[string]string{})
-		items[parts[2]] = strings.Join(parts[3:], " ")
-		if err := p.cfg.SetMap(parts[1], items); err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set error: %s", err))
-			return true
-		}
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("Set %s", parts[1]))
+func (p *AdminPlugin) passwordCmd(r bot.Request) bool {
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, p.bot.GetPassword())
 	return true
 }
 
-	if parts[0] == "get" && len(parts) == 2 && forbiddenKeys[parts[1]] {
-		p.bot.Send(conn, bot.Message, message.Channel, "You cannot access that key")
-		return true
-	} else if parts[0] == "get" && len(parts) == 2 {
-		v := p.cfg.Get(parts[1], "<unknown>")
-		p.bot.Send(conn, bot.Message, message.Channel, fmt.Sprintf("%s: %s", parts[1], v))
-		return true
-	}
-
-	return false
-}
-
-func (p *AdminPlugin) handleVariables(conn bot.Connector, message msg.Message) bool {
-	if parts := strings.SplitN(message.Body, "!=", 2); len(parts) == 2 {
-		variable := strings.ToLower(strings.TrimSpace(parts[0]))
-		value := strings.TrimSpace(parts[1])
-
-		_, err := p.db.Exec(`delete from variables where name=? and value=?`, variable, value)
-		if err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, "I'm broke and need attention in my variable creation code.")
-			log.Error().Err(err)
-		} else {
-			p.bot.Send(conn, bot.Message, message.Channel, "Removed.")
-		}
-
-		return true
-	}
-
-	parts := strings.SplitN(message.Body, "=", 2)
-	if len(parts) != 2 {
-		return false
-	}
-
-	variable := strings.ToLower(strings.TrimSpace(parts[0]))
-	value := strings.TrimSpace(parts[1])
+func (p *AdminPlugin) variableSetCmd(r bot.Request) bool {
+	variable := strings.ToLower(r.Values["var"])
+	value := r.Values["value"]
 
 	var count int64
 	row := p.db.QueryRow(`select count(*) from variables where value = ?`, variable, value)
 	err := row.Scan(&count)
 	if err != nil {
-		p.bot.Send(conn, bot.Message, message.Channel, "I'm broke and need attention in my variable creation code.")
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "I'm broke and need attention in my variable creation code.")
 		log.Error().Err(err)
 		return true
 	}
 
 	if count > 0 {
-		p.bot.Send(conn, bot.Message, message.Channel, "I've already got that one.")
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "I've already got that one.")
 	} else {
 		_, err := p.db.Exec(`INSERT INTO variables (name, value) VALUES (?, ?)`, variable, value)
 		if err != nil {
-			p.bot.Send(conn, bot.Message, message.Channel, "I'm broke and need attention in my variable creation code.")
+			p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "I'm broke and need attention in my variable creation code.")
 			log.Error().Err(err)
 			return true
 		}
-		p.bot.Send(conn, bot.Message, message.Channel, "Added.")
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "Added.")
 	}
 	return true
 }
 
+func (p *AdminPlugin) variableUnSetCmd(r bot.Request) bool {
+	variable := strings.ToLower(r.Values["var"])
+	value := r.Values["value"]
+
+	_, err := p.db.Exec(`delete from variables where name=? and value=?`, variable, value)
+	if err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "I'm broke and need attention in my variable creation code.")
+		log.Error().Err(err)
+	} else {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "Removed.")
+	}
+
+	return true
+}
+
+func (p *AdminPlugin) unsetConfigCmd(r bot.Request) bool {
+	key := r.Values["key"]
+	if forbiddenKeys[key] {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You cannot access that key")
+		return true
+	}
+	if err := p.cfg.Unset(key); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Unset error: %s", err))
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Unset %s", key))
+	return true
+}
+
+func (p *AdminPlugin) setConfigCmd(r bot.Request) bool {
+	key, value := r.Values["key"], r.Values["value"]
+	if forbiddenKeys[key] {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You cannot access that key")
+		return true
+	}
+	if err := p.cfg.Set(key, value); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set error: %s", err))
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set %s", key))
+	return true
+}
+
+func (p *AdminPlugin) pushConfigCmd(r bot.Request) bool {
+	key, value := r.Values["key"], r.Values["value"]
+	if forbiddenKeys[key] {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You cannot access that key")
+		return true
+	}
+	items := p.cfg.GetArray(key, []string{})
+	items = append(items, value)
+	if err := p.cfg.Set(key, strings.Join(items, ";;")); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set error: %s", err))
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set %s", key))
+	return true
+}
+
+func (p *AdminPlugin) setKeyConfigCmd(r bot.Request) bool {
+	key, name, value := r.Values["key"], r.Values["name"], r.Values["value"]
+	if forbiddenKeys[key] {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You cannot access that key")
+		return true
+	}
+	items := p.cfg.GetMap(key, map[string]string{})
+	items[name] = value
+	if err := p.cfg.SetMap(key, items); err != nil {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set error: %s", err))
+		return true
+	}
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Set %s", key))
+	return true
+}
+
+func (p *AdminPlugin) getConfigCmd(r bot.Request) bool {
+	key := r.Values["key"]
+	if forbiddenKeys[key] {
+		p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You cannot access that key")
+		return true
+	}
+	v := p.cfg.Get(key, "<unknown>")
+	p.bot.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("%s: %s", key, v))
+	return true
+}
+
 // Help responds to help requests. Every plugin must implement a help function.
 func (p *AdminPlugin) help(conn bot.Connector, kind bot.Kind, m msg.Message, args ...interface{}) bool {
 	p.bot.Send(conn, bot.Message, m.Channel, "This does super secret things that you're not allowed to know about.")

plugins/admin/admin_test.go

@@ -1,6 +1,7 @@
 package admin
 
 import (
+	"regexp"
 	"strings"
 	"testing"
 
@@ -28,24 +29,30 @@ func setup(t *testing.T) (*AdminPlugin, *bot.MockBot) {
 	return a, mb
 }
 
-func makeMessage(payload string) (bot.Connector, bot.Kind, msg.Message) {
+func makeMessage(payload string, r *regexp.Regexp) bot.Request {
 	isCmd := strings.HasPrefix(payload, "!")
 	if isCmd {
 		payload = payload[1:]
 	}
 	c := cli.CliPlugin{}
-	return &c, bot.Message, msg.Message{
+	values := bot.ParseValues(r, payload)
+	return bot.Request{
+		Conn:   &c,
+		Kind:   bot.Message,
+		Values: values,
+		Msg: msg.Message{
 			User:    &user.User{Name: "admin"},
 			Channel: "test",
 			Body:    payload,
 			Command: isCmd,
+		},
 	}
 }
 
 func TestSet(t *testing.T) {
 	a, mb := setup(t)
 	expected := "test value"
-	a.message(makeMessage("!set test.key " + expected))
+	a.setConfigCmd(makeMessage("!set test.key "+expected, setConfigRegex))
 	actual := mb.Config().Get("test.key", "ERR")
 	assert.Equal(t, expected, actual)
 }
@@ -54,7 +61,7 @@ func TestGetValue(t *testing.T) {
 	a, mb := setup(t)
 	expected := "value"
 	mb.Config().Set("test.key", "value")
-	a.message(makeMessage("!get test.key"))
+	a.getConfigCmd(makeMessage("!get test.key", getConfigRegex))
 	assert.Len(t, mb.Messages, 1)
 	assert.Contains(t, mb.Messages[0], expected)
 }
@@ -62,7 +69,7 @@ func TestGetValue(t *testing.T) {
 func TestGetEmpty(t *testing.T) {
 	a, mb := setup(t)
 	expected := "test.key: <unknown>"
-	a.message(makeMessage("!get test.key"))
+	a.getConfigCmd(makeMessage("!get test.key", getConfigRegex))
 	assert.Len(t, mb.Messages, 1)
 	assert.Equal(t, expected, mb.Messages[0])
 }
@@ -70,7 +77,7 @@ func TestGetEmpty(t *testing.T) {
 func TestGetForbidden(t *testing.T) {
 	a, mb := setup(t)
 	expected := "cannot access"
-	a.message(makeMessage("!get slack.token"))
+	a.getConfigCmd(makeMessage("!get slack.token", getConfigRegex))
 	assert.Len(t, mb.Messages, 1)
 	assert.Contains(t, mb.Messages[0], expected)
 }

plugins/aoc/aoc.go

@@ -2,6 +2,7 @@ package aoc
 
 import (
 	"fmt"
+	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -10,7 +11,6 @@ import (
 	"code.chrissexton.org/cws/getaoc"
 
 	"github.com/velour/catbase/bot"
-	"github.com/velour/catbase/bot/msg"
 	"github.com/velour/catbase/config"
 )
 
@@ -24,42 +24,35 @@ func New(b bot.Bot) *AOC {
 		b: b,
 		c: b.Config(),
 	}
-	b.Register(aoc, bot.Message, aoc.message)
+	b.RegisterRegexCmd(aoc, bot.Message, aocRegex, aoc.aocCmd)
 	return aoc
 }
 
-func (p *AOC) message(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
-	if !message.Command {
-		return false
-	}
-	cleaned := strings.TrimSpace(strings.ToLower(message.Body))
-	fields := strings.Split(cleaned, " ")
-	if strings.HasPrefix(cleaned, "aoc") {
+var aocRegex = regexp.MustCompile(`(?i)^aoc\s?(?P<year>\S+)?$`)
+
+func (p *AOC) aocCmd(r bot.Request) bool {
 	year := time.Now().Year()
-		if len(fields) > 1 {
-			year, _ = strconv.Atoi(fields[1])
+	if time.Now().Month() < 11 {
+		year--
+	}
+	if r.Values["year"] != "" {
+		year, _ = strconv.Atoi(r.Values["year"])
 	}
 	boardId := p.c.GetInt("aoc.board", 0)
 	var err error
-		if len(fields) > 2 {
-			boardId, err = strconv.Atoi(fields[2])
-			if err != nil {
-				p.b.Send(c, bot.Message, message.Channel, fmt.Sprintf("Error getting leaderboard: %s", err))
-				return true
-			}
-		}
+
 	session := p.c.Get("aoc.session", "")
 	if session == "" {
-			p.b.Send(c, bot.Message, message.Channel, "Error getting leaderboard: must have a session ID.")
+		p.b.Send(r.Conn, bot.Message, r.Msg.Channel, "Error getting leaderboard: must have a session ID.")
 		return true
 	}
 	if boardId == 0 {
-			p.b.Send(c, bot.Message, message.Channel, "Error getting leaderboard: must have a board ID.")
+		p.b.Send(r.Conn, bot.Message, r.Msg.Channel, "Error getting leaderboard: must have a board ID.")
 		return true
 	}
 	board, err := getaoc.GetLeaderboard(session, year, boardId)
 	if err != nil {
-			p.b.Send(c, bot.Message, message.Channel, fmt.Sprintf("Error getting leaderboard: %s", err))
+		p.b.Send(r.Conn, bot.Message, r.Msg.Channel, fmt.Sprintf("Error getting leaderboard: %s", err))
 		return true
 	}
 
@@ -88,7 +81,7 @@ func (p *AOC) message(c bot.Connector, kind bot.Kind, message msg.Message, args
 		}
 	}
 
-		link := c.URLFormat("leaderboard", fmt.Sprintf("https://adventofcode.com/%d/leaderboard/private/view/%d", year, boardId))
+	link := r.Conn.URLFormat("leaderboard", fmt.Sprintf("https://adventofcode.com/%d/leaderboard/private/view/%d", year, boardId))
 	msg := fmt.Sprintf("AoC %s:\n", link)
 	for _, m := range members {
 		if m.Stars == 0 {
@@ -97,18 +90,16 @@ func (p *AOC) message(c bot.Connector, kind bot.Kind, message msg.Message, args
 		trophy := ""
 		switch m.ID {
 		case goldID:
-				trophy = c.Emojy(":gold-trophy:")
+			trophy = r.Conn.Emojy(":gold-trophy:")
 		case silverID:
-				trophy = c.Emojy(":silver-trophy:")
+			trophy = r.Conn.Emojy(":silver-trophy:")
 		case bronzeID:
-				trophy = c.Emojy(":bronze-trophy:")
+			trophy = r.Conn.Emojy(":bronze-trophy:")
 		}
 		msg += fmt.Sprintf("%s has %d :star: for a score of %d%s\n", m.Name, m.Stars, m.LocalScore, trophy)
 	}
 	msg = strings.TrimSpace(msg)
 
-		p.b.Send(c, bot.Message, message.Channel, msg)
+	p.b.Send(r.Conn, bot.Message, r.Msg.Channel, msg)
 	return true
 }
-	return false
-}

plugins/babbler/babbler.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"math/rand"
+	"regexp"
 	"strings"
 
 	"github.com/rs/zerolog/log"
@@ -26,6 +27,8 @@ type BabblerPlugin struct {
 	Bot            bot.Bot
 	db             *sqlx.DB
 	WithGoRoutines bool
+
+	handlers bot.HandlerTable
 }
 
 type Babbler struct {
@@ -95,57 +98,87 @@ func New(b bot.Bot) *BabblerPlugin {
 
 	plugin.createNewWord("")
 
-	b.Register(plugin, bot.Message, plugin.message)
-	b.Register(plugin, bot.Help, plugin.help)
+	plugin.register()
 
 	return plugin
 }
 
-func (p *BabblerPlugin) message(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
-	lowercase := strings.ToLower(message.Body)
-	tokens := strings.Fields(lowercase)
-	numTokens := len(tokens)
-
+func (p *BabblerPlugin) register() {
+	p.handlers = bot.HandlerTable{
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^(?P<who>\S+) says-bridge (?P<start>.+)\|(?P<end>.+)$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				start := strings.Fields(strings.ToLower(r.Values["start"]))
+				end := strings.Fields(strings.ToLower(r.Values["end"]))
+				return p.sayIt(r, p.getBabbleWithBookends(who, start, end))
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^(?P<who>\S+) says-tail (?P<what>.*)$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				what := strings.Fields(strings.ToLower(r.Values["what"]))
+				return p.sayIt(r, p.getBabbleWithSuffix(who, what))
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^(?P<who>\S+) says-middle-out (?P<what>.*)$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				what := strings.ToLower(r.Values["what"])
+				tokens := strings.Fields(what)
 				saidSomething := false
 				saidWhat := ""
 
-	if numTokens > 2 && tokens[1] == "says-bridge" && strings.Contains(lowercase, "|") {
-		split := strings.Split(lowercase, "|")
-		start := strings.Fields(split[0])
-		end := strings.Fields(split[1])
-		saidWhat, saidSomething = p.getBabbleWithBookends(start, end)
-	} else if numTokens >= 2 && tokens[1] == "says" {
-		saidWhat, saidSomething = p.getBabble(tokens)
-	} else if numTokens > 2 && tokens[1] == "says-tail" {
-		saidWhat, saidSomething = p.getBabbleWithSuffix(tokens)
-	} else if numTokens >= 2 && tokens[1] == "says-middle-out" {
-		saidWhatStart, saidSomethingStart := p.getBabbleWithSuffix(tokens)
-		neverSaidLooksLike := fmt.Sprintf("%s never said '%s'", tokens[0], strings.Join(tokens[2:], " "))
-		if !saidSomethingStart || saidWhatStart == neverSaidLooksLike {
+				saidWhatStart := p.getBabbleWithSuffix(who, tokens)
+				saidSomethingStart := saidWhatStart != ""
+				neverSaidLooksLike := fmt.Sprintf("%s never said", who)
+				if !saidSomethingStart || strings.HasPrefix(saidWhatStart, neverSaidLooksLike) {
 					saidSomething = saidSomethingStart
 					saidWhat = saidWhatStart
 				} else {
-			saidWhatEnd, saidSomethingEnd := p.getBabble(tokens)
+					saidWhatEnd := p.getBabble(who, tokens)
+					saidSomethingEnd := saidWhatEnd != ""
 					saidSomething = saidSomethingStart && saidSomethingEnd
 					if saidSomething {
-				saidWhat = saidWhatStart + " " + strings.Join(strings.Fields(saidWhatEnd)[len(tokens)-2:], " ")
+						saidWhat = saidWhatStart + strings.TrimPrefix(saidWhatEnd, what)
 					}
 				}
-	} else if len(tokens) == 4 && strings.Index(lowercase, "initialize babbler for ") == 0 {
-		saidWhat, saidSomething = p.initializeBabbler(tokens)
-	} else if strings.Index(lowercase, "batch learn for ") == 0 {
-		saidWhat, saidSomething = p.batchLearn(tokens)
-	} else if len(tokens) == 5 && strings.Index(lowercase, "merge babbler") == 0 {
-		saidWhat, saidSomething = p.merge(tokens)
-	} else {
-		//this should always return "", false
-		saidWhat, saidSomething = p.addToBabbler(message.User.Name, lowercase)
+				return p.sayIt(r, saidWhat)
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false, Regex: regexp.MustCompile(`(?i)^(?P<who>\S+) (says (?P<what>.*)?|says)$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				what := strings.Fields(strings.ToLower(r.Values["what"]))
+				return p.sayIt(r, p.getBabble(who, what))
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^initialize babbler for (?P<who>\S+)$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				return p.sayIt(r, p.initializeBabbler(who))
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^merge babbler (?P<from>\S+) into (?P<to>\S+)$`),
+			Handler: func(r bot.Request) bool {
+				from, to := r.Values["from"], r.Values["to"]
+				return p.sayIt(r, p.merge(from, to))
+			}},
+		bot.HandlerSpec{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`.*`),
+			Handler: func(r bot.Request) bool {
+				p.addToBabbler(r.Msg.User.Name, strings.ToLower(r.Msg.Body))
+				return false
+			}},
+	}
+	p.Bot.RegisterTable(p, p.handlers)
+	p.Bot.Register(p, bot.Help, p.help)
 }
 
-	if saidSomething {
-		p.Bot.Send(c, bot.Message, message.Channel, saidWhat)
+func (p *BabblerPlugin) sayIt(r bot.Request, what string) bool {
+	if what != "" {
+		p.Bot.Send(r.Conn, bot.Message, r.Msg.Channel, what)
 	}
-	return saidSomething
+	return what != ""
 }
 
 func (p *BabblerPlugin) help(c bot.Connector, kind bot.Kind, msg msg.Message, args ...interface{}) bool {

plugins/babbler/babbler_test.go

@@ -3,27 +3,34 @@
 package babbler
 
 import (
-	"github.com/velour/catbase/plugins/cli"
+	"regexp"
 	"strings"
 	"testing"
 
+	"github.com/velour/catbase/plugins/cli"
+
 	"github.com/stretchr/testify/assert"
 	"github.com/velour/catbase/bot"
 	"github.com/velour/catbase/bot/msg"
 	"github.com/velour/catbase/bot/user"
 )
 
-func makeMessage(payload string) (bot.Connector, bot.Kind, msg.Message) {
+func makeMessage(payload string, r *regexp.Regexp) bot.Request {
 	c := &cli.CliPlugin{}
 	isCmd := strings.HasPrefix(payload, "!")
 	if isCmd {
 		payload = payload[1:]
 	}
-	return c, bot.Message, msg.Message{
+	return bot.Request{
+		Conn:   c,
+		Kind:   bot.Message,
+		Values: bot.ParseValues(r, payload),
+		Msg: msg.Message{
 			User:    &user.User{Name: "tester"},
 			Channel: "test",
 			Body:    payload,
 			Command: isCmd,
+		},
 	}
 }
 
@@ -39,11 +46,23 @@ func newBabblerPlugin(mb *bot.MockBot) *BabblerPlugin {
 	return bp
 }
 
+func testMessage(p *BabblerPlugin, msg string) bool {
+	for _, h := range p.handlers {
+		if h.Regex.MatchString(msg) {
+			req := makeMessage(msg, h.Regex)
+			if h.Handler(req) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 func TestBabblerNoBabbler(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	bp.message(makeMessage("!seabass2 says"))
+	testMessage(bp, "!seabass2 says")
 	res := assert.Len(t, mb.Messages, 0)
 	assert.True(t, res)
 	// assert.Contains(t, mb.Messages[0], "seabass2 babbler not found")
@@ -53,229 +72,176 @@ func TestBabblerNothingSaid(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	res := bp.message(makeMessage("initialize babbler for seabass"))
+	res := testMessage(bp, "initialize babbler for seabass")
 	assert.True(t, res)
-	res = bp.message(makeMessage("!seabass says"))
+	res = testMessage(bp, "seabass says")
 	assert.True(t, res)
-	assert.Len(t, mb.Messages, 2)
+	if assert.Len(t, mb.Messages, 2) {
 		assert.Contains(t, mb.Messages[0], "okay.")
 		assert.Contains(t, mb.Messages[1], "seabass hasn't said anything yet.")
 	}
+}
 
 func TestBabbler(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says"))
-	assert.Len(t, mb.Messages, 1)
+	testMessage(bp, "!initialize babbler for tester")
+	testMessage(bp, "This is a message")
+	testMessage(bp, "This is another message")
+	testMessage(bp, "This is a long message")
+	res := testMessage(bp, "!tester says")
 	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
 		assert.Contains(t, mb.Messages[0], "this is")
 		assert.Contains(t, mb.Messages[0], "message")
 	}
+}
 
 func TestBabblerSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says long"))
-	assert.Len(t, mb.Messages, 1)
+
+	testMessage(bp, "This is a message")
+	testMessage(bp, "This is another message")
+	testMessage(bp, "This is a long message")
+	res := testMessage(bp, "tester says long")
 	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
 		assert.Contains(t, mb.Messages[0], "long message")
 	}
+}
 
 func TestBabblerMultiSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says This is a long"))
-	assert.Len(t, mb.Messages, 1)
-	assert.True(t, res)
-	assert.Contains(t, mb.Messages[0], "this is a long message")
-}
 
-func TestBabblerMultiSeed2(t *testing.T) {
-	mb := bot.NewMockBot()
-	bp := newBabblerPlugin(mb)
-	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says is a long"))
-	assert.Len(t, mb.Messages, 1)
+	testMessage(bp, "This is a message")
+	testMessage(bp, "This is another message")
+	testMessage(bp, "This is a long message")
+	res := testMessage(bp, "tester says is another")
 	assert.True(t, res)
-	assert.Contains(t, mb.Messages[0], "is a long message")
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "is another")
+	}
 }
 
 func TestBabblerBadSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	bp.message(c, k, seabass)
-	bp.message(makeMessage("!seabass says noooo this is bad"))
-	assert.Len(t, mb.Messages, 1)
-	assert.Contains(t, mb.Messages[0], "seabass never said 'noooo this is bad'")
+
+	testMessage(bp, "This is a message")
+	testMessage(bp, "This is another message")
+	testMessage(bp, "This is a long message")
+	res := testMessage(bp, "tester says this is bad")
+	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "tester never said 'this is bad'")
+	}
 }
 
 func TestBabblerBadSeed2(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	bp.message(c, k, seabass)
-	seabass.Body = "This is another message"
-	bp.message(c, k, seabass)
-	seabass.Body = "This is a long message"
-	bp.message(c, k, seabass)
-	bp.message(makeMessage("!seabass says This is a really"))
-	assert.Len(t, mb.Messages, 1)
-	assert.Contains(t, mb.Messages[0], "seabass never said 'this is a really'")
+
+	testMessage(bp, "This is a message")
+	testMessage(bp, "This is another message")
+	testMessage(bp, "This is a long message")
+	res := testMessage(bp, "tester says This is a really")
+	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "tester never said 'this is a really'")
+	}
 }
 
 func TestBabblerSuffixSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is message one")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "It's easier to test with unique messages"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "hi there"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-tail message one"))
-	res = bp.message(makeMessage("!seabass says-tail with unique"))
-	assert.Len(t, mb.Messages, 2)
+
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	testMessage(bp, "tester says-tail message one")
+	res := testMessage(bp, "tester says-tail with unique")
 	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 2) {
 		assert.Contains(t, mb.Messages[0], "this is message one")
 		assert.Contains(t, mb.Messages[1], "it's easier to test with unique")
 	}
+}
 
 func TestBabblerBadSuffixSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("This is message one")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	seabass.Body = "It's easier to test with unique messages"
-	res = bp.message(c, k, seabass)
-	seabass.Body = "hi there"
-	res = bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-tail anything true"))
-	assert.Len(t, mb.Messages, 1)
+
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	res := testMessage(bp, "tester says-tail anything true")
 	assert.True(t, res)
-	assert.Contains(t, mb.Messages[0], "seabass never said 'anything true'")
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "tester never said 'anything true'")
+	}
 }
 
 func TestBabblerBookendSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("It's easier to test with unique messages")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-bridge It's easier | unique messages"))
-	assert.Len(t, mb.Messages, 1)
+
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	res := testMessage(bp, "tester says-bridge it's easier | unique messages")
 	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
 		assert.Contains(t, mb.Messages[0], "it's easier to test with unique messages")
 	}
-
-func TestBabblerBookendSeedShort(t *testing.T) {
-	mb := bot.NewMockBot()
-	bp := newBabblerPlugin(mb)
-	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("It's easier to test with unique messages")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-bridge It's easier to test with | unique messages"))
-	assert.Len(t, mb.Messages, 1)
-	assert.True(t, res)
-	assert.Contains(t, mb.Messages[0], "it's easier to test with unique messages")
 }
 
 func TestBabblerBadBookendSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("It's easier to test with unique messages")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-bridge It's easier | not unique messages"))
-	assert.Len(t, mb.Messages, 1)
+
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	res := testMessage(bp, "tester says-bridge says-bridge It's easier | not unique messages")
 	assert.True(t, res)
-	assert.Contains(t, mb.Messages[0], "seabass never said 'it's easier ... not unique messages'")
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "tester never said 'it's easier ... not unique messages'")
+	}
 }
 
 func TestBabblerMiddleOutSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("It's easier to test with unique messages")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-middle-out test with"))
-	assert.Len(t, mb.Messages, 1)
+
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	res := testMessage(bp, "tester says-middle-out test with")
 	assert.True(t, res)
+	if assert.Len(t, mb.Messages, 1) {
 		assert.Contains(t, mb.Messages[0], "it's easier to test with unique messages")
 	}
+}
 
 func TestBabblerBadMiddleOutSeed(t *testing.T) {
 	mb := bot.NewMockBot()
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("It's easier to test with unique messages")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
-	res = bp.message(makeMessage("!seabass says-middle-out anything true"))
-	assert.Len(t, mb.Messages, 1)
-	assert.True(t, res)
-	assert.Equal(t, mb.Messages[0], "seabass never said 'anything true'")
-}
 
-func TestBabblerBatch(t *testing.T) {
-	mb := bot.NewMockBot()
-	bp := newBabblerPlugin(mb)
-	assert.NotNil(t, bp)
-	c, k, seabass := makeMessage("batch learn for seabass This is a message! This is another message. This is not a long message? This is not a message! This is not another message. This is a long message?")
-	res := bp.message(c, k, seabass)
-	assert.Len(t, mb.Messages, 1)
-	res = bp.message(makeMessage("!seabass says"))
-	assert.Len(t, mb.Messages, 2)
+	testMessage(bp, "This is message one")
+	testMessage(bp, "It's easier to test with unique messages")
+	res := testMessage(bp, "tester says-middle-out anything true")
 	assert.True(t, res)
-	assert.Contains(t, mb.Messages[1], "this is")
-	assert.Contains(t, mb.Messages[1], "message")
+	if assert.Len(t, mb.Messages, 1) {
+		assert.Contains(t, mb.Messages[0], "tester never said 'anything true'")
+	}
 }
 
 func TestBabblerMerge(t *testing.T) {
@@ -283,29 +249,24 @@ func TestBabblerMerge(t *testing.T) {
 	bp := newBabblerPlugin(mb)
 	assert.NotNil(t, bp)
 
-	c, k, seabass := makeMessage("<seabass> This is a message")
-	seabass.User = &user.User{Name: "seabass"}
-	res := bp.message(c, k, seabass)
+	testMessage(bp, "<tester> This is a message")
 	assert.Len(t, mb.Messages, 0)
 
-	seabass.Body = "<seabass> This is another message"
-	res = bp.message(c, k, seabass)
-
-	seabass.Body = "<seabass> This is a long message"
-	res = bp.message(c, k, seabass)
-
-	res = bp.message(makeMessage("!merge babbler seabass into seabass2"))
+	testMessage(bp, "<tester> This is another message")
+	testMessage(bp, "<tester> This is a long message")
+	res := testMessage(bp, "merge babbler tester into tester2")
 	assert.True(t, res)
-	assert.Len(t, mb.Messages, 1)
+	if assert.Len(t, mb.Messages, 1) {
 		assert.Contains(t, mb.Messages[0], "mooooiggged")
+	}
 
-	res = bp.message(makeMessage("!seabass2 says"))
+	res = testMessage(bp, "!tester2 says")
 	assert.True(t, res)
-	assert.Len(t, mb.Messages, 2)
-
-	assert.Contains(t, mb.Messages[1], "<seabass2> this is")
+	if assert.Len(t, mb.Messages, 2) {
+		assert.Contains(t, mb.Messages[1], "<tester2> this is")
 		assert.Contains(t, mb.Messages[1], "message")
 	}
+}
 
 func TestHelp(t *testing.T) {
 	mb := bot.NewMockBot()

plugins/babbler/commands.go

@@ -5,117 +5,112 @@ import (
 	"strings"
 )
 
-func (p *BabblerPlugin) initializeBabbler(tokens []string) (string, bool) {
-	who := tokens[3]
+func (p *BabblerPlugin) initializeBabbler(who string) string {
 	_, err := p.getOrCreateBabbler(who)
 	if err != nil {
-		return "babbler initialization failed.", true
+		return "babbler initialization failed."
 	}
-	return "okay.", true
+	return "okay."
 }
 
-func (p *BabblerPlugin) addToBabbler(babblerName, whatWasSaid string) (string, bool) {
-	babblerId, err := p.getOrCreateBabbler(babblerName)
+func (p *BabblerPlugin) addToBabbler(babblerName, whatWasSaid string) {
+	babblerID, err := p.getOrCreateBabbler(babblerName)
 	if err == nil {
 		if p.WithGoRoutines {
-			go p.addToMarkovChain(babblerId, whatWasSaid)
+			go p.addToMarkovChain(babblerID, whatWasSaid)
 		} else {
-			p.addToMarkovChain(babblerId, whatWasSaid)
+			p.addToMarkovChain(babblerID, whatWasSaid)
 		}
 	}
-	return "", false
 }
 
-func (p *BabblerPlugin) getBabble(tokens []string) (string, bool) {
-	who := tokens[0]
+func (p *BabblerPlugin) getBabble(who string, tokens []string) string {
 	_, err := p.getBabbler(who)
 
 	if err != nil {
 		if err == NO_BABBLER {
 			// return fmt.Sprintf("%s babbler not found.", who), true
-			return "", false
+			return ""
 		}
 	} else {
 
 		var saying string
-		if len(tokens) == 2 {
+		if len(tokens) == 0 {
 			saying, err = p.babble(who)
 		} else {
-			saying, err = p.babbleSeed(who, tokens[2:])
+			saying, err = p.babbleSeed(who, tokens)
 		}
 
 		if err != nil {
 			if err == SAID_NOTHING {
-				return fmt.Sprintf("%s hasn't said anything yet.", who), true
+				return fmt.Sprintf("%s hasn't said anything yet.", who)
 			} else if err == NEVER_SAID {
-				return fmt.Sprintf("%s never said '%s'", who, strings.Join(tokens[2:], " ")), true
+				return fmt.Sprintf("%s never said '%s'", who, strings.Join(tokens, " "))
 			}
 		} else if saying != "" {
-			return saying, true
+			return saying
 		}
 	}
-	return "", false
+	return ""
 }
 
-func (p *BabblerPlugin) getBabbleWithSuffix(tokens []string) (string, bool) {
-	who := tokens[0]
+func (p *BabblerPlugin) getBabbleWithSuffix(who string, tokens []string) string {
 	_, err := p.getBabbler(who)
 
 	if err != nil {
 		if err == NO_BABBLER {
 			// return fmt.Sprintf("%s babbler not found.", who), true
-			return "", false
+			return ""
 		}
 	} else {
 
-		saying, err := p.babbleSeedSuffix(who, tokens[2:])
+		saying, err := p.babbleSeedSuffix(who, tokens)
 
 		if err != nil {
 			if err == SAID_NOTHING {
-				return fmt.Sprintf("%s hasn't said anything yet.", who), true
+				return fmt.Sprintf("%s hasn't said anything yet.", who)
 			} else if err == NEVER_SAID {
-				return fmt.Sprintf("%s never said '%s'", who, strings.Join(tokens[2:], " ")), true
+				return fmt.Sprintf("%s never said '%s'", who, strings.Join(tokens, " "))
 			}
 		} else if saying != "" {
-			return saying, true
+			return saying
 		}
 	}
-	return "", false
+	return ""
 }
 
-func (p *BabblerPlugin) getBabbleWithBookends(start, end []string) (string, bool) {
-	who := start[0]
+func (p *BabblerPlugin) getBabbleWithBookends(who string, start, end []string) string {
 	_, err := p.getBabbler(who)
 
 	if err != nil {
 		if err == NO_BABBLER {
 			// return fmt.Sprintf("%s babbler not found.", who), true
-			return "", false
+			return ""
 		}
 	} else {
 
-		saying, err := p.babbleSeedBookends(who, start[2:], end)
+		saying, err := p.babbleSeedBookends(who, start, end)
 
 		if err != nil {
 			if err == SAID_NOTHING {
-				return fmt.Sprintf("%s hasn't said anything yet.", who), true
+				return fmt.Sprintf("%s hasn't said anything yet.", who)
 			} else if err == NEVER_SAID {
-				seeds := append(start[2:], "...")
+				seeds := append(start[1:], "...")
 				seeds = append(seeds, end...)
-				return fmt.Sprintf("%s never said '%s'", who, strings.Join(seeds, " ")), true
+				return fmt.Sprintf("%s never said '%s'", who, strings.Join(seeds, " "))
 			}
 		} else if saying != "" {
-			return saying, true
+			return saying
 		}
 	}
-	return "", false
+	return ""
 }
 
-func (p *BabblerPlugin) batchLearn(tokens []string) (string, bool) {
+func (p *BabblerPlugin) batchLearn(tokens []string) string {
 	who := tokens[3]
 	babblerId, err := p.getOrCreateBabbler(who)
 	if err != nil {
-		return "batch learn failed.", true
+		return "batch learn failed."
 	}
 
 	body := strings.Join(tokens[4:], " ")
@@ -133,37 +128,30 @@ func (p *BabblerPlugin) batchLearn(tokens []string) (string, bool) {
 			}
 		}
 	}
-	return "phew that was tiring.", true
+	return "phew that was tiring."
 }
 
-func (p *BabblerPlugin) merge(tokens []string) (string, bool) {
-	if tokens[3] != "into" {
-		return "try using 'merge babbler [x] into [y]'", true
-	}
-
-	who := tokens[2]
-	into := tokens[4]
-
+func (p *BabblerPlugin) merge(who, into string) string {
 	if who == into {
-		return "that's annoying. stop it.", true
+		return "that's annoying. stop it."
 	}
 
 	whoBabbler, err := p.getBabbler(who)
 	if err != nil {
 		if err == NO_BABBLER {
-			return fmt.Sprintf("%s babbler not found.", who), true
+			return fmt.Sprintf("%s babbler not found.", who)
 		}
-		return "merge failed.", true
+		return "merge failed."
 	}
 	intoBabbler, err := p.getOrCreateBabbler(into)
 	if err != nil {
-		return "merge failed.", true
+		return "merge failed."
 	}
 
 	err = p.mergeBabblers(intoBabbler, whoBabbler, into, who)
 	if err != nil {
-		return "merge failed.", true
+		return "merge failed."
 	}
 
-	return "mooooiggged", true
+	return "mooooiggged"
 }

plugins/gpt2/gpt2.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"regexp"
 	"strings"
 
 	"github.com/velour/catbase/bot"
@@ -23,28 +24,23 @@ func New(b bot.Bot) *GPT2Plugin {
 		c: b.Config(),
 	}
 
-	b.Register(p, bot.Message, p.message)
+	b.RegisterRegexCmd(p, bot.Message, gpt2Regex, p.gpt2Cmd)
 	b.Register(p, bot.Help, p.help)
 
 	return p
 }
 
-const prefix = "gpt2"
+var gpt2Regex = regexp.MustCompile(`(?i)^gpt2 (?P<input>.*)$`)
 
-func (p *GPT2Plugin) message(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
-	ch := message.Channel
-	lowerBody := strings.ToLower(message.Body)
-	if message.Command && strings.HasPrefix(lowerBody, prefix) {
-		input := message.Body[len(prefix)+1:]
+func (p *GPT2Plugin) gpt2Cmd(r bot.Request) bool {
+	input := r.Values["input"]
 	txt, err := p.getGPTText(input)
 	if err != nil {
 		txt = p.c.Get("gpt.error", "The GPT service is unavailable.")
 	}
-		p.b.Send(c, bot.Message, ch, txt)
+	p.b.Send(r.Conn, bot.Message, r.Msg.Channel, txt)
 	return true
 }
-	return false
-}
 
 func (p *GPT2Plugin) help(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
 	txt := "Invoke the GPT-2 API with: `!gpt2 <your seed text>"