mirror of
https://github.com/diamondburned/arikawa.git
synced 2024-09-06 18:27:19 +00:00
373 lines
7.6 KiB
Go
373 lines
7.6 KiB
Go
package bot
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
|
|
"github.com/diamondburned/arikawa/gateway"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
var (
|
|
typeMessageCreate = reflect.TypeOf((*gateway.MessageCreateEvent)(nil))
|
|
|
|
typeSubcmd = reflect.TypeOf((*Subcommand)(nil))
|
|
|
|
typeIError = reflect.TypeOf((*error)(nil)).Elem()
|
|
typeIManP = reflect.TypeOf((*ManualParseable)(nil)).Elem()
|
|
typeIParser = reflect.TypeOf((*Parseable)(nil)).Elem()
|
|
typeSetupFn = func() reflect.Type {
|
|
method, _ := reflect.TypeOf((*CanSetup)(nil)).
|
|
Elem().
|
|
MethodByName("Setup")
|
|
return method.Type
|
|
}()
|
|
)
|
|
|
|
type Subcommand struct {
|
|
Description string
|
|
|
|
// Raw struct name, including the flag (only filled for actual subcommands,
|
|
// will be empty for Context):
|
|
StructName string
|
|
// Parsed command name:
|
|
Command string
|
|
|
|
// All registered command contexts:
|
|
Commands []*CommandContext
|
|
Events []*CommandContext
|
|
|
|
// Middleware command contexts:
|
|
mwMethods []*CommandContext
|
|
|
|
// struct flags
|
|
Flag NameFlag
|
|
|
|
// Directly to struct
|
|
cmdValue reflect.Value
|
|
cmdType reflect.Type
|
|
|
|
// Pointer value
|
|
ptrValue reflect.Value
|
|
ptrType reflect.Type
|
|
|
|
// command interface as reference
|
|
command interface{}
|
|
}
|
|
|
|
// CommandContext is an internal struct containing fields to make this library
|
|
// work. As such, they're all unexported. Description, however, is exported for
|
|
// editing, and may be used to generate more informative help messages.
|
|
type CommandContext struct {
|
|
Description string
|
|
Flag NameFlag
|
|
|
|
MethodName string
|
|
Command string
|
|
|
|
value reflect.Value // Func
|
|
event reflect.Type // gateway.*Event
|
|
method reflect.Method
|
|
|
|
Arguments []Argument
|
|
}
|
|
|
|
// CanSetup is used for subcommands to change variables, such as Description.
|
|
// This method will be triggered when InitCommands is called, which is during
|
|
// New for Context and during RegisterSubcommand for subcommands.
|
|
type CanSetup interface {
|
|
// Setup should panic when it has an error.
|
|
Setup(*Subcommand)
|
|
}
|
|
|
|
func (cctx *CommandContext) Usage() []string {
|
|
if len(cctx.Arguments) == 0 {
|
|
return nil
|
|
}
|
|
|
|
var arguments = make([]string, len(cctx.Arguments))
|
|
for i, arg := range cctx.Arguments {
|
|
arguments[i] = arg.String
|
|
}
|
|
|
|
return arguments
|
|
}
|
|
|
|
func NewSubcommand(cmd interface{}) (*Subcommand, error) {
|
|
var sub = Subcommand{
|
|
command: cmd,
|
|
}
|
|
|
|
if err := sub.reflectCommands(); err != nil {
|
|
return nil, errors.Wrap(err, "Failed to reflect commands")
|
|
}
|
|
|
|
if err := sub.parseCommands(); err != nil {
|
|
return nil, errors.Wrap(err, "Failed to parse commands")
|
|
}
|
|
|
|
return &sub, nil
|
|
}
|
|
|
|
// NeedsName sets the name for this subcommand. Like InitCommands, this
|
|
// shouldn't be called at all, rather you should use RegisterSubcommand.
|
|
func (sub *Subcommand) NeedsName() {
|
|
sub.StructName = sub.cmdType.Name()
|
|
|
|
flag, name := ParseFlag(sub.StructName)
|
|
|
|
if !flag.Is(Raw) {
|
|
name = lowerFirstLetter(name)
|
|
}
|
|
|
|
sub.Command = name
|
|
sub.Flag = flag
|
|
}
|
|
|
|
// ChangeCommandInfo changes the matched methodName's Command and Description.
|
|
// Empty means unchanged. The returned bool is true when the method is found.
|
|
func (sub *Subcommand) ChangeCommandInfo(methodName, cmd, desc string) bool {
|
|
for _, c := range sub.Commands {
|
|
if c.MethodName != methodName {
|
|
continue
|
|
}
|
|
|
|
if cmd != "" {
|
|
c.Command = cmd
|
|
}
|
|
if desc != "" {
|
|
c.Description = desc
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (sub *Subcommand) Help(prefix, indent string, hideAdmin bool) string {
|
|
if sub.Flag.Is(AdminOnly) && hideAdmin {
|
|
return ""
|
|
}
|
|
|
|
if len(sub.Commands) == 0 {
|
|
return ""
|
|
}
|
|
|
|
var subHelp string
|
|
if sub.Command != "" {
|
|
subHelp += indent + sub.Command
|
|
}
|
|
|
|
if sub.Description != "" {
|
|
if subHelp != "" {
|
|
subHelp += ": "
|
|
} else {
|
|
subHelp += indent
|
|
}
|
|
|
|
subHelp += sub.Description
|
|
}
|
|
|
|
subHelp += "\n"
|
|
|
|
for _, cmd := range sub.Commands {
|
|
if cmd.Flag.Is(AdminOnly) && hideAdmin {
|
|
continue
|
|
}
|
|
|
|
subHelp += indent + indent +
|
|
prefix + sub.Command + " " + cmd.Command
|
|
|
|
switch {
|
|
case len(cmd.Usage()) > 0:
|
|
subHelp += " " + strings.Join(cmd.Usage(), " ")
|
|
case cmd.Description != "":
|
|
subHelp += ": " + cmd.Description
|
|
}
|
|
|
|
subHelp += "\n"
|
|
}
|
|
|
|
return subHelp
|
|
}
|
|
|
|
func (sub *Subcommand) reflectCommands() error {
|
|
t := reflect.TypeOf(sub.command)
|
|
v := reflect.ValueOf(sub.command)
|
|
|
|
if t.Kind() != reflect.Ptr {
|
|
return errors.New("sub is not a pointer")
|
|
}
|
|
|
|
// Set the pointer fields
|
|
sub.ptrValue = v
|
|
sub.ptrType = t
|
|
|
|
ts := t.Elem()
|
|
vs := v.Elem()
|
|
|
|
if ts.Kind() != reflect.Struct {
|
|
return errors.New("sub is not pointer to struct")
|
|
}
|
|
|
|
// Set the struct fields
|
|
sub.cmdValue = vs
|
|
sub.cmdType = ts
|
|
|
|
return nil
|
|
}
|
|
|
|
// InitCommands fills a Subcommand with a context. This shouldn't be called at
|
|
// all, rather you should use the RegisterSubcommand method of a Context.
|
|
func (sub *Subcommand) InitCommands(ctx *Context) error {
|
|
// Start filling up a *Context field
|
|
if err := sub.fillStruct(ctx); err != nil {
|
|
return err
|
|
}
|
|
|
|
// See if struct implements CanSetup:
|
|
if v, ok := sub.command.(CanSetup); ok {
|
|
v.Setup(sub)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (sub *Subcommand) fillStruct(ctx *Context) error {
|
|
for i := 0; i < sub.cmdValue.NumField(); i++ {
|
|
field := sub.cmdValue.Field(i)
|
|
|
|
if !field.CanSet() || !field.CanInterface() {
|
|
continue
|
|
}
|
|
|
|
if _, ok := field.Interface().(*Context); !ok {
|
|
continue
|
|
}
|
|
|
|
field.Set(reflect.ValueOf(ctx))
|
|
return nil
|
|
}
|
|
|
|
return errors.New("No fields with *Command found")
|
|
}
|
|
|
|
func (sub *Subcommand) parseCommands() error {
|
|
var numMethods = sub.ptrValue.NumMethod()
|
|
|
|
for i := 0; i < numMethods; i++ {
|
|
method := sub.ptrValue.Method(i)
|
|
|
|
if !method.CanInterface() {
|
|
continue
|
|
}
|
|
|
|
methodT := method.Type()
|
|
numArgs := methodT.NumIn()
|
|
|
|
if numArgs == 0 {
|
|
// Doesn't meet the requirement for an event, continue.
|
|
continue
|
|
}
|
|
|
|
if methodT == typeSetupFn {
|
|
// Method is a setup method, continue.
|
|
continue
|
|
}
|
|
|
|
// Check number of returns:
|
|
if methodT.NumOut() != 1 {
|
|
continue
|
|
}
|
|
|
|
// Check return type
|
|
if err := methodT.Out(0); err == nil || !err.Implements(typeIError) {
|
|
// Invalid, skip
|
|
continue
|
|
}
|
|
|
|
var command = CommandContext{
|
|
method: sub.ptrType.Method(i),
|
|
value: method,
|
|
event: methodT.In(0), // parse event
|
|
}
|
|
|
|
// Parse the method name
|
|
flag, name := ParseFlag(command.method.Name)
|
|
|
|
// Set the method name, command, and flag:
|
|
command.MethodName = name
|
|
command.Command = name
|
|
command.Flag = flag
|
|
|
|
// Check if Raw is enabled for command:
|
|
if !flag.Is(Raw) {
|
|
command.Command = lowerFirstLetter(name)
|
|
}
|
|
|
|
// Middlewares shouldn't even have arguments.
|
|
if flag.Is(Middleware) {
|
|
sub.mwMethods = append(sub.mwMethods, &command)
|
|
continue
|
|
}
|
|
|
|
// TODO: allow more flexibility
|
|
if command.event != typeMessageCreate || flag.Is(Hidden) {
|
|
sub.Events = append(sub.Events, &command)
|
|
continue
|
|
}
|
|
|
|
// If the method only takes an event:
|
|
if numArgs == 1 {
|
|
// done
|
|
goto Done
|
|
}
|
|
|
|
// If the second argument implements ParseContent()
|
|
if t := methodT.In(1); t.Implements(typeIManP) {
|
|
mt, _ := t.MethodByName("ParseContent")
|
|
|
|
if t.Kind() == reflect.Ptr {
|
|
t = t.Elem()
|
|
}
|
|
|
|
command.Arguments = []Argument{{
|
|
String: t.String(),
|
|
Type: t,
|
|
manual: mt,
|
|
}}
|
|
|
|
goto Done
|
|
}
|
|
|
|
command.Arguments = make([]Argument, 0, numArgs)
|
|
|
|
// Fill up arguments
|
|
for i := 1; i < numArgs; i++ {
|
|
t := methodT.In(i)
|
|
|
|
avfs, err := getArgumentValueFn(t)
|
|
if err != nil {
|
|
return errors.Wrap(err, "Error parsing argument "+t.String())
|
|
}
|
|
|
|
command.Arguments = append(command.Arguments, Argument{
|
|
String: t.String(),
|
|
Type: t,
|
|
fn: avfs,
|
|
})
|
|
}
|
|
|
|
Done:
|
|
// Append
|
|
sub.Commands = append(sub.Commands, &command)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func lowerFirstLetter(name string) string {
|
|
return strings.ToLower(string(name[0])) + name[1:]
|
|
}
|