[WIP] parser: framework started

internal/commands/commands.go

@@ -8,9 +8,11 @@ func Commands() []*cmd.Command {
 		ping,
 		purge,
 		uptime,
+		update,
 		nitro,
 		debug,
 		helpCommands,
 		help,
+		lex,
 	}
 }

internal/commands/lex.go

@@ -0,0 +1,78 @@
+package commands
+
+import "github.com/the-sanctuary/waddles/pkg/cmd"
+
+/* === top level command === */
+var lex *cmd.Command = &cmd.Command{
+	Name:        "lex",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex (add|list|remove|manage)",
+	SubCommands: []*cmd.Command{lexAdd, lexList, lexRemove, lexManage},
+}
+
+/* === primary subcommands === */
+var lexAdd *cmd.Command = &cmd.Command{
+	Name:        "add",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex add <slug>",
+	SubCommands: []*cmd.Command{},
+}
+
+var lexList *cmd.Command = &cmd.Command{
+	Name:        "list",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex list",
+	SubCommands: []*cmd.Command{},
+}
+
+var lexRemove *cmd.Command = &cmd.Command{
+	Name:        "remove",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex remove <slug>",
+	SubCommands: []*cmd.Command{},
+}
+
+var lexManage *cmd.Command = &cmd.Command{
+	Name:        "manage",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex manage (add|remove|edit|tags)",
+	SubCommands: []*cmd.Command{lexManageAdd, lexManageRemove},
+}
+
+/* === secondary subommands */
+var lexManageAdd *cmd.Command = &cmd.Command{
+	Name:        "add",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex manage add <slug> <name> [<tag>] <description>",
+	SubCommands: []*cmd.Command{},
+}
+
+var lexManageRemove *cmd.Command = &cmd.Command{
+	Name:        "remove",
+	Aliases:     []string{""},
+	Description: "Temporary command to test the lexer and parser (based on topics).",
+	Usage:       "lex manage <slug>",
+	SubCommands: []*cmd.Command{},
+}
+
+// var lexManageEdit *cmd.Command = &cmd.Command{
+// 	Name:        "edit",
+// 	Aliases:     []string{""},
+// 	Description: "Temporary command to test the lexer and parser (based on topics).",
+// 	Usage:       "lex manage edit",
+// 	SubCommands: []*cmd.Command{},
+// }
+
+// var lexManageTags *cmd.Command = &cmd.Command{
+// 	Name:        "tags",
+// 	Aliases:     []string{""},
+// 	Description: "Temporary command to test the lexer and parser (based on topics).",
+// 	Usage:       "lex manage tags",
+// 	SubCommands: []*cmd.Command{},
+// }

internal/commands/update.go

@@ -76,6 +76,8 @@ var updateGatekeeper *cmd.Command = &cmd.Command{
 			"You may decline to accept these rules, but you will be not be granted access to the server, and will instead be kicked.\n\n" +
 			"Please type `accept`, to accept the rules above, or `decline`, to leave the server.")
 
+		log.Trace().Msgf("%s", msg)
+
 		// Send the message to the channel specified in the gatekeeper config
 		c.Session.ChannelMessageSend(config.Gatekeeper.ChannelID, msg)
 	},

pkg/cmd/context.go

@@ -68,6 +68,7 @@ func (ctx *Context) ReplyError(err error) bool {
 	return false
 }
 
+// ReplyTimeDeleteStringf just putting this here to get rid of the warning
 func (ctx *Context) ReplyTimeDeleteStringf(delay time.Duration, format string, a ...interface{}) {
 	errMsg := ctx.ReplyStringf(format, a...)
 

pkg/cmd/router.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/the-sanctuary/waddles/pkg/cfg"
 	"github.com/the-sanctuary/waddles/pkg/db"
+	"github.com/the-sanctuary/waddles/pkg/parser"
 	"github.com/the-sanctuary/waddles/pkg/permissions"
 	"github.com/the-sanctuary/waddles/pkg/util"
 )
@@ -21,15 +22,17 @@ type Router struct {
 	WadlDB     *db.WadlDB
 	PermSystem *permissions.PermissionSystem
 	Config     *cfg.Config
+	Parser     *parser.Parser
 }
 
 //BuildRouter returns a fully built router stuct with commands preregistered
-func BuildRouter(wdb *db.WadlDB, permSystem *permissions.PermissionSystem, cfg *cfg.Config) Router {
+func BuildRouter(wdb *db.WadlDB, permSystem *permissions.PermissionSystem, cfg *cfg.Config, parser *parser.Parser) Router {
 	r := Router{
 		Prefix:     cfg.Wadl.Prefix,
 		WadlDB:     wdb,
 		PermSystem: permSystem,
 		Config:     cfg,
+		Parser:     parser,
 	}
 
 	return r
@@ -85,6 +88,10 @@ func (r *Router) Handler() func(*discordgo.Session, *discordgo.MessageCreate) {
 		split := strings.Split(message.Content[len(r.Prefix):], " ")
 		correct, cmd := triggerCheck(split[0], r.Commands)
 
+		tree := parser.BuildCmdTree()
+		r.Parser.Parse(split[0], tree)
+		tree.LRTraverse()
+
 		if correct {
 			deepestCmd, args, node := findDeepestCommand(cmd, split, cmd.Name)
 
@@ -126,6 +133,7 @@ func defaultHandler(ctx *Context) {
 	ctx.ReplyString(builder.String())
 }
 
+// RBuildHelp helps build :P
 func RBuildHelp(c *Context, builder *strings.Builder, cmds []*Command, depth int) {
 	for _, cmd := range cmds {
 		if cmd.HideInHelp {

pkg/parser/lexer.go

@@ -0,0 +1,16 @@
+package parser
+
+type Lexer struct {
+	Lexemes map[string][]string
+}
+
+// BuildLexer returns a Lexer with the proper keyowrds and tokens
+func BuildLexer() Lexer {
+	lex := Lexer{}
+
+	// Define the lexemes for our lexer
+	lex.Lexemes = map[string][]string{
+		"<cmd>": {""},
+	}
+	return lex
+}

pkg/parser/parser.go

@@ -0,0 +1,43 @@
+package parser
+
+// Parser object to hold data of the command parser
+type Parser struct {
+	StringDelims []string
+	LRDelims     []string
+}
+
+// BuildParser constructor-like factory function for the Parser object
+func BuildParser(stringDelims []string) Parser {
+	p := Parser{}
+	for _, sd := range stringDelims {
+		if len(sd) == 1 {
+			p.StringDelims = append(p.StringDelims, sd)
+		} else if len(sd) == 2 {
+			p.LRDelims = append(p.LRDelims, string(sd[0]))
+			p.LRDelims = append(p.LRDelims, string(sd[1]))
+		}
+	}
+	return p
+}
+
+// Parse parses a command string into a command tree
+func (p *Parser) Parse(raw string, tree *CmdTree) {
+	c1 := BuildCmdTreeArg("hello")
+	c2 := BuildCmdTreeArg("world")
+	tree.Data = raw
+	tree.Trees = []*CmdTree{c1, c2}
+}
+
+// func isCmdOrSubCmd(cmd string, commands []cmd.Command) bool {
+// 	for _, command := range commands {
+// 		if command.Name == cmd {
+// 			return true
+// 		}
+// 		for _, subCommand := range command.SubCommands {
+// 			if subCommand.Name == cmd {
+// 				return true
+// 			}
+// 		}
+// 	}
+// 	return false
+// }

pkg/parser/tree.go

@@ -0,0 +1,39 @@
+package parser
+
+import "github.com/rs/zerolog/log"
+
+// CmdTree tree object for holding a parsed command string
+type CmdTree struct {
+	Data  string
+	Trees []*CmdTree
+}
+
+// BuildCmdTree constructor-like factory function for the CmdTree object
+func BuildCmdTree() *CmdTree {
+	tree := &CmdTree{
+		Data:  "",
+		Trees: []*CmdTree{},
+	}
+	return tree
+}
+
+// BuildCmdTreeArg constructor-like factory function for the CmdTree object and passing in data
+func BuildCmdTreeArg(data string) *CmdTree {
+	tree := &CmdTree{
+		Data:  data,
+		Trees: []*CmdTree{},
+	}
+	return tree
+}
+
+// LRTraverse traverses a CmdTree object from bottom up, left to right
+func (t *CmdTree) LRTraverse() {
+	if len(t.Trees) == 0 {
+		log.Trace().Msgf("LRTraverse> %s", t.Data)
+		return
+	}
+	for _, tree := range t.Trees {
+		tree.LRTraverse()
+	}
+	log.Trace().Msgf("LRTraverse> %s", t.Data)
+}

pkg/waddles/waddles.go

@@ -7,6 +7,7 @@ import (
 	"github.com/the-sanctuary/waddles/internal/handlers"
 	"github.com/the-sanctuary/waddles/pkg/cfg"
 	"github.com/the-sanctuary/waddles/pkg/cmd"
+	"github.com/the-sanctuary/waddles/pkg/parser"
 
 	"github.com/the-sanctuary/waddles/pkg/db"
 	"github.com/the-sanctuary/waddles/pkg/handler"
@@ -45,7 +46,13 @@ func (w *Waddles) Run() {
 
 	permSystem := permissions.BuildPermissionSystem(cfg.Cfg().GetConfigFileLocation("permissions.toml"))
 
-	r := cmd.BuildRouter(w.Database, &permSystem, cfg.Cfg())
+	// Build the parser
+	parser := parser.BuildParser([]string{"\"", "'", "<>", "()"})
+	log.Trace().Msgf("String Delims: %s", parser.StringDelims)
+	log.Trace().Msgf("String Delims: %s", parser.LRDelims)
+
+	// Build the router
+	r := cmd.BuildRouter(w.Database, &permSystem, cfg.Cfg(), &parser)
 
 	r.RegisterCommands(commands.Commands())