dice: refactor

plugins/beers/beers.go

@@ -14,6 +14,7 @@ import (
 	"net/http"
 	"net/url"
 	"path"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -41,6 +42,7 @@ type BeersPlugin struct {
 	db *sqlx.DB
 
 	untapdCache map[int]bool
+	handlers    bot.HandlerTable
 }
 
 type untappdUser struct {
@@ -70,7 +72,7 @@ func New(b bot.Bot) *BeersPlugin {
 		untapdCache: make(map[int]bool),
 	}
 
-	b.Register(p, bot.Message, p.message)
+	p.register()
 	b.Register(p, bot.Help, p.help)
 
 	p.registerWeb()
@@ -88,89 +90,86 @@ func New(b bot.Bot) *BeersPlugin {
 	return p
 }
 
-// Message responds to the bot hook on recieving messages.
+func (p *BeersPlugin) register() {
-// This function returns true if the plugin responds in a meaningful way to the users message.
+	p.handlers = bot.HandlerTable{
-// Otherwise, the function returns false and the bot continues execution of other plugins.
+		{Kind: bot.Message, IsCmd: false,
-func (p *BeersPlugin) message(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
+			Regex: regexp.MustCompile(`(?i)^beers?\s?(?P<operator>(\+=|-=|=))\s?(?P<amount>\d+)$`),
-	parts := strings.Fields(message.Body)
+			Handler: func(r bot.Request) bool {
+				op := r.Values["operator"]
+				count, _ := strconv.Atoi(r.Values["amount"])
+				nick := r.Msg.User.Name
 
-	if len(parts) == 0 {
+				switch op {
-		return false
+				case "=":
-	}
-
-	channel := message.Channel
-	user := message.User
-	nick := user.Name
-
-	// respond to the beers type of queries
-	parts[0] = strings.ToLower(parts[0]) // support iPhone/Android saying "Beers"
-	if parts[0] == "beers" {
-		if len(parts) == 3 {
-
-			// try to get a count out of parts[2]
-			count, err := strconv.Atoi(parts[2])
-			if err != nil {
-				// if it's not a number, maybe it's a nick!
-				p.b.Send(c, bot.Message, channel, "Sorry, that didn't make any sense.")
-			}
-
-			if count < 0 {
-				// you can't be negative
-				msg := fmt.Sprintf("Sorry %s, you can't have negative beers!", nick)
-				p.b.Send(c, bot.Message, channel, msg)
-				return true
-			}
-			if parts[1] == "+=" {
-				p.addBeers(nick, count)
-				p.randomReply(c, channel)
-			} else if parts[1] == "=" {
 					if count == 0 {
-					p.puke(c, nick, channel)
+						p.puke(r.Conn, nick, r.Msg.Channel)
 					} else {
 						p.setBeers(nick, count)
-					p.randomReply(c, channel)
+						p.randomReply(r.Conn, r.Msg.Channel)
 					}
-			} else {
-				p.b.Send(c, bot.Message, channel, "I don't know your math.")
-			}
-		} else if len(parts) == 2 {
-			if p.doIKnow(parts[1]) {
-				p.reportCount(c, parts[1], channel, false)
-			} else {
-				msg := fmt.Sprintf("Sorry, I don't know %s.", parts[1])
-				p.b.Send(c, bot.Message, channel, msg)
-			}
-		} else if len(parts) == 1 {
-			p.reportCount(c, nick, channel, true)
-		}
-
-		// no matter what, if we're in here, then we've responded
 					return true
-	} else if parts[0] == "puke" {
+				case "+=":
-		p.puke(c, nick, channel)
+					p.addBeers(nick, count)
+					p.randomReply(r.Conn, r.Msg.Channel)
+					return true
+				case "-=":
+					p.addBeers(nick, -count)
+					p.randomReply(r.Conn, r.Msg.Channel)
 					return true
 				}
-
+				return false
-	if message.Command && parts[0] == "imbibe" {
+			}},
+		{Kind: bot.Message, IsCmd: false,
+			Regex: regexp.MustCompile(`(?i)^beers?\s?(?P<operator>(\+\+|--))$`),
+			Handler: func(r bot.Request) bool {
+				op := r.Values["operator"]
+				nick := r.Msg.User.Name
+				if op == "++" {
 					p.addBeers(nick, 1)
-		p.randomReply(c, channel)
+				} else {
+					p.addBeers(nick, -1)
+				}
+				p.randomReply(r.Conn, r.Msg.Channel)
 				return true
+			}},
+		{Kind: bot.Message, IsCmd: true,
+			Regex: regexp.MustCompile(`(?i)^beers( (?P<who>\S+))?$`),
+			Handler: func(r bot.Request) bool {
+				who := r.Values["who"]
+				if who == "" {
+					who = r.Msg.User.Name
 				}
-
+				if p.doIKnow(who) {
-	if message.Command && parts[0] == "reguntappd" {
+					p.reportCount(r.Conn, who, r.Msg.Channel, false)
-		chanNick := message.User.Name
+				} else {
-		channel := message.Channel
+					msg := fmt.Sprintf("Sorry, I don't know %s.", who)
-
+					p.b.Send(r.Conn, bot.Message, r.Msg.Channel, msg)
-		if len(parts) < 2 {
-			p.b.Send(c, bot.Message, channel, "You must also provide a user name.")
-		} else if len(parts) == 3 {
-			chanNick = parts[2]
-		} else if len(parts) == 4 {
-			chanNick = parts[2]
-			channel = parts[3]
 				}
+				return true
+			}},
+		{Kind: bot.Message, IsCmd: true,
+			Regex: regexp.MustCompile(`(?i)^puke$`),
+			Handler: func(r bot.Request) bool {
+				p.puke(r.Conn, r.Msg.User.Name, r.Msg.Channel)
+				return true
+			}},
+		{Kind: bot.Message, IsCmd: true,
+			Regex: regexp.MustCompile(`(?i)^` +
+				strings.Join(p.c.GetArray("beers.imbibewords", []string{"imbibe", "quaff"}), "|") + `$`),
+			Handler: func(r bot.Request) bool {
+				p.addBeers(r.Msg.User.Name, 1)
+				p.randomReply(r.Conn, r.Msg.Channel)
+				return true
+			}},
+		{Kind: bot.Message, IsCmd: true,
+			Regex: regexp.MustCompile(`(?i)^reguntappd (?P<who>\S+)$`),
+			Handler: func(r bot.Request) bool {
+				chanNick := r.Msg.User.Name
+				channel := r.Msg.Channel
+				untappdNick := r.Values["who"]
+
 				u := untappdUser{
-			untappdUser: parts[1],
+					untappdUser: untappdNick,
 					chanNick:    chanNick,
 					channel:     channel,
 				}
@@ -187,7 +186,7 @@ func (p *BeersPlugin) message(c bot.Connector, kind bot.Kind, message msg.Messag
 					log.Error().Err(err).Msgf("Error registering untappd")
 				}
 				if count > 0 {
-			p.b.Send(c, bot.Message, channel, "I'm already watching you.")
+					p.b.Send(r.Conn, bot.Message, channel, "I'm already watching you.")
 					return true
 				}
 				_, err = p.db.Exec(`insert into untappd (
@@ -203,28 +202,32 @@ func (p *BeersPlugin) message(c bot.Connector, kind bot.Kind, message msg.Messag
 				)
 				if err != nil {
 					log.Error().Err(err).Msgf("Error registering untappd")
-			p.b.Send(c, bot.Message, channel, "I can't see.")
+					p.b.Send(r.Conn, bot.Message, channel, "I can't see.")
 					return true
 				}
 
-		p.b.Send(c, bot.Message, channel, "I'll be watching you.")
+				p.b.Send(r.Conn, bot.Message, channel, "I'll be watching you.")
 
-		p.checkUntappd(c, channel)
+				p.checkUntappd(r.Conn, channel)
 
 				return true
-	}
+			}},
-
+		{Kind: bot.Message, IsCmd: true,
-	if message.Command && parts[0] == "checkuntappd" {
+			Regex: regexp.MustCompile(`(?i)^checkuntappd$`),
+			Handler: func(r bot.Request) bool {
 				log.Info().
-			Str("user", message.User.Name).
+					Str("user", r.Msg.User.Name).
 					Msgf("Checking untappd at request of user.")
-		p.checkUntappd(c, channel)
+				p.checkUntappd(r.Conn, r.Msg.Channel)
 				return true
+			}},
 	}
-
+	p.b.RegisterTable(p, p.handlers)
-	return false
 }
 
+// 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.
 // Help responds to help requests. Every plugin must implement a help function.
 func (p *BeersPlugin) help(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
 	msg := "Beers: imbibe by using either beers +=,=,++ or with the !imbibe/drink " +
@@ -280,11 +283,7 @@ func (p *BeersPlugin) puke(c bot.Connector, user string, channel string) {
 }
 
 func (p *BeersPlugin) doIKnow(nick string) bool {
-	var count int
+	count := p.getBeers(nick)
-	err := p.db.QueryRow(`select count(*) from beers where nick = ?`, nick).Scan(&count)
-	if err != nil {
-		return false
-	}
 	return count > 0
 }
 

plugins/beers/beers_test.go

@@ -3,6 +3,7 @@
 package beers
 
 import (
+	"regexp"
 	"strings"
 	"testing"
 
@@ -15,27 +16,45 @@ import (
 	"github.com/velour/catbase/plugins/counter"
 )
 
-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: "tester"},
 			Channel: "test",
 			Body:    payload,
 			Command: isCmd,
+		},
 	}
 }
 
+func testMessage(p *BeersPlugin, 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 makeBeersPlugin(t *testing.T) (*BeersPlugin, *bot.MockBot) {
 	mb := bot.NewMockBot()
 	counter.New(mb)
 	mb.DB().MustExec(`delete from counter; delete from counter_alias;`)
 	b := New(mb)
-	b.message(makeMessage("!mkalias beer :beer:"))
+	counter.MkAlias(mb.DB(), "beer", ":beer:")
-	b.message(makeMessage("!mkalias beers :beer:"))
+	counter.MkAlias(mb.DB(), "beers", ":beer:")
 	return b, mb
 }
 
@@ -52,9 +71,9 @@ func TestCounter(t *testing.T) {
 
 func TestImbibe(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("!imbibe"))
+	testMessage(b, "imbibe")
 	assert.Len(t, mb.Messages, 1)
-	b.message(makeMessage("!imbibe"))
+	testMessage(b, "imbibe")
 	assert.Len(t, mb.Messages, 2)
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
@@ -62,26 +81,17 @@ func TestImbibe(t *testing.T) {
 }
 func TestEq(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("!beers = 3"))
+	testMessage(b, "beers = 3")
 	assert.Len(t, mb.Messages, 1)
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
 	assert.Equal(t, 3, it.Count)
 }
 
-func TestEqNeg(t *testing.T) {
-	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("!beers = -3"))
-	assert.Len(t, mb.Messages, 1)
-	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
-	assert.Nil(t, err)
-	assert.Equal(t, 0, it.Count)
-}
-
 func TestEqZero(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("beers += 5"))
+	testMessage(b, "beers += 5")
-	b.message(makeMessage("!beers = 0"))
+	testMessage(b, "beers = 0")
 	assert.Len(t, mb.Messages, 2)
 	assert.Contains(t, mb.Messages[1], "reversal of fortune")
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
@@ -91,9 +101,9 @@ func TestEqZero(t *testing.T) {
 
 func TestBeersPlusEq(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("beers += 5"))
+	testMessage(b, "beers += 5")
 	assert.Len(t, mb.Messages, 1)
-	b.message(makeMessage("beers += 5"))
+	testMessage(b, "beers += 5")
 	assert.Len(t, mb.Messages, 2)
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
@@ -102,11 +112,11 @@ func TestBeersPlusEq(t *testing.T) {
 
 func TestPuke(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("beers += 5"))
+	testMessage(b, "beers += 5")
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
 	assert.Equal(t, 5, it.Count)
-	b.message(makeMessage("puke"))
+	testMessage(b, "puke")
 	it, err = counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
 	assert.Equal(t, 0, it.Count)
@@ -114,12 +124,14 @@ func TestPuke(t *testing.T) {
 
 func TestBeersReport(t *testing.T) {
 	b, mb := makeBeersPlugin(t)
-	b.message(makeMessage("beers += 5"))
+	testMessage(b, "beers += 5")
 	it, err := counter.GetUserItem(mb.DB(), "tester", itemName)
 	assert.Nil(t, err)
 	assert.Equal(t, 5, it.Count)
-	b.message(makeMessage("beers"))
+	testMessage(b, "beers")
+	if assert.Len(t, mb.Messages, 2) {
 		assert.Contains(t, mb.Messages[1], "5 beers")
+	}
 }
 
 func TestHelp(t *testing.T) {

plugins/dice/dice.go

@@ -2,14 +2,14 @@
 
 package dice
 
-import (
-	"github.com/velour/catbase/bot"
-	"github.com/velour/catbase/bot/msg"
-)
-
 import (
 	"fmt"
 	"math/rand"
+	"regexp"
+	"strconv"
+
+	"github.com/velour/catbase/bot"
+	"github.com/velour/catbase/bot/msg"
 )
 
 // This is a dice plugin to serve as an example and quick copy/paste for new plugins.
@@ -18,12 +18,12 @@ type DicePlugin struct {
 	Bot bot.Bot
 }
 
-// NewDicePlugin creates a new DicePlugin with the Plugin interface
+// New creates a new DicePlugin with the Plugin interface
 func New(b bot.Bot) *DicePlugin {
 	dp := &DicePlugin{
 		Bot: b,
 	}
-	b.Register(dp, bot.Message, dp.message)
+	b.RegisterRegexCmd(dp, bot.Message, rollRegex, dp.rollCmd)
 	b.Register(dp, bot.Help, dp.help)
 	return dp
 }
@@ -32,28 +32,18 @@ func rollDie(sides int) int {
 	return rand.Intn(sides) + 1
 }
 
-// Message responds to the bot hook on recieving messages.
+var rollRegex = regexp.MustCompile(`^(?P<number>\d+)d(?P<sides>\d+)$`)
-// 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 *DicePlugin) message(c bot.Connector, kind bot.Kind, message msg.Message, args ...interface{}) bool {
-	if !message.Command {
-		return false
-	}
 
-	channel := message.Channel
+func (p *DicePlugin) rollCmd(r bot.Request) bool {
-	nDice := 0
+	nDice, _ := strconv.Atoi(r.Values["number"])
-	sides := 0
+	sides, _ := strconv.Atoi(r.Values["sides"])
-
-	if n, err := fmt.Sscanf(message.Body, "%dd%d", &nDice, &sides); n != 2 || err != nil {
-		return false
-	}
 
 	if sides < 2 || nDice < 1 || nDice > 20 {
-		p.Bot.Send(c, bot.Message, channel, "You're a dick.")
+		p.Bot.Send(r.Conn, bot.Message, r.Msg.Channel, "You're a dick.")
 		return true
 	}
 
-	rolls := fmt.Sprintf("%s, you rolled: ", message.User.Name)
+	rolls := fmt.Sprintf("%s, you rolled: ", r.Msg.User.Name)
 
 	for i := 0; i < nDice; i++ {
 		rolls = fmt.Sprintf("%s %d", rolls, rollDie(sides))
@@ -64,9 +54,8 @@ func (p *DicePlugin) message(c bot.Connector, kind bot.Kind, message msg.Message
 		}
 	}
 
-	p.Bot.Send(c, bot.Message, channel, rolls)
+	p.Bot.Send(r.Conn, bot.Message, r.Msg.Channel, rolls)
 	return true
-
 }
 
 // Help responds to help requests. Every plugin must implement a help function.

plugins/dice/dice_test.go

@@ -3,26 +3,33 @@
 package dice
 
 import (
-	"github.com/velour/catbase/plugins/cli"
 	"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) bot.Request {
 	isCmd := strings.HasPrefix(payload, "!")
 	if isCmd {
 		payload = payload[1:]
 	}
-	return &cli.CliPlugin{}, bot.Message, msg.Message{
+	values := bot.ParseValues(rollRegex, payload)
+	return bot.Request{
+		Conn:   &cli.CliPlugin{},
+		Kind:   bot.Message,
+		Values: values,
+		Msg: msg.Message{
 			User:    &user.User{Name: "tester"},
 			Channel: "test",
 			Body:    payload,
 			Command: isCmd,
+		},
 	}
 }
 
@@ -30,7 +37,7 @@ func TestDie(t *testing.T) {
 	mb := bot.NewMockBot()
 	c := New(mb)
 	assert.NotNil(t, c)
-	res := c.message(makeMessage("!1d6"))
+	res := c.rollCmd(makeMessage("1d6"))
 	assert.Len(t, mb.Messages, 1)
 	assert.True(t, res)
 	assert.Contains(t, mb.Messages[0], "tester, you rolled:")
@@ -40,44 +47,17 @@ func TestDice(t *testing.T) {
 	mb := bot.NewMockBot()
 	c := New(mb)
 	assert.NotNil(t, c)
-	res := c.message(makeMessage("!5d6"))
+	res := c.rollCmd(makeMessage("5d6"))
 	assert.Len(t, mb.Messages, 1)
 	assert.True(t, res)
 	assert.Contains(t, mb.Messages[0], "tester, you rolled:")
 }
 
-func TestNotCommand(t *testing.T) {
-	mb := bot.NewMockBot()
-	c := New(mb)
-	assert.NotNil(t, c)
-	res := c.message(makeMessage("1d6"))
-	assert.False(t, res)
-	assert.Len(t, mb.Messages, 0)
-}
-
-func TestBadDice(t *testing.T) {
-	mb := bot.NewMockBot()
-	c := New(mb)
-	assert.NotNil(t, c)
-	res := c.message(makeMessage("!aued6"))
-	assert.False(t, res)
-	assert.Len(t, mb.Messages, 0)
-}
-
-func TestBadSides(t *testing.T) {
-	mb := bot.NewMockBot()
-	c := New(mb)
-	assert.NotNil(t, c)
-	res := c.message(makeMessage("!1daoeu"))
-	assert.False(t, res)
-	assert.Len(t, mb.Messages, 0)
-}
-
 func TestLotsOfDice(t *testing.T) {
 	mb := bot.NewMockBot()
 	c := New(mb)
 	assert.NotNil(t, c)
-	res := c.message(makeMessage("!100d100"))
+	res := c.rollCmd(makeMessage("100d100"))
 	assert.True(t, res)
 	assert.Len(t, mb.Messages, 1)
 	assert.Contains(t, mb.Messages[0], "You're a dick.")