1
0
Fork 0
mirror of https://github.com/diamondburned/arikawa.git synced 2024-12-11 16:05:00 +00:00
arikawa/utils/bot/arguments.go
2021-09-18 00:39:34 -07:00

269 lines
5.7 KiB
Go

package bot
import (
"errors"
"reflect"
"strconv"
"strings"
)
type argumentValueFn func(string) (reflect.Value, error)
// Parser implements a Parse(string) method for data structures that can be
// used as arguments.
type Parser interface {
Parse(string) error
}
// Usager is used in place of the automatically parsed struct name for Parser
// and other interfaces.
type Usager interface {
Usage() string
}
// ManualParser has a ParseContent(string) method. If the library sees
// this for an argument, it will send all of the arguments into the method. If
// used, this should be the only argument followed after the Message Create
// event. Any more and the router will ignore.
type ManualParser interface {
// $0 will have its prefix trimmed.
ParseContent([]string) error
}
// ArgumentParts implements ManualParser, in case you want to parse arguments
// manually. It borrows the library's argument parser.
type ArgumentParts []string
var _ ManualParser = (*ArgumentParts)(nil)
// ParseContent implements ManualParser.
func (r *ArgumentParts) ParseContent(args []string) error {
*r = args
return nil
}
func (r ArgumentParts) Arg(n int) string {
if n < 0 || n >= len(r) {
return ""
}
return r[n]
}
func (r ArgumentParts) After(n int) string {
if n < 0 || n > len(r) {
return ""
}
return strings.Join(r[n:], " ")
}
func (r ArgumentParts) String() string {
return strings.Join(r, " ")
}
func (r ArgumentParts) Length() int {
return len(r)
}
// Usage implements Usager.
func (r ArgumentParts) Usage() string {
return "strings"
}
// CustomParser has a CustomParse method, which would be passed in the full
// message content with the prefix, command, subcommand and space trimmed. This
// is used for commands that require more advanced parsing than the default
// parser.
type CustomParser interface {
CustomParse(arguments string) error
}
// RawArguments implements the CustomParser interface, which sets all the
// arguments into it as raw as it could.
type RawArguments string
var _ CustomParser = (*RawArguments)(nil)
func (a *RawArguments) CustomParse(arguments string) error {
*a = RawArguments(arguments)
return nil
}
// Argument is each argument in a method.
type Argument struct {
String string
// Rule: pointer for structs, direct for primitives
rtype reflect.Type
// indicates if the type is referenced, meaning it's a pointer but not the
// original call.
pointer bool
// if nil, then manual
fn argumentValueFn
manual func(ManualParser, []string) error
custom func(CustomParser, string) error
}
func (a *Argument) Type() reflect.Type {
return a.rtype
}
var ShellwordsEscaper = strings.NewReplacer(
"\\", "\\\\",
)
// nilV, only used to return an error
var nilV = reflect.Value{}
func newArgument(t reflect.Type, variadic bool) (*Argument, error) {
// Allow array types if variadic is true.
if variadic && t.Kind() == reflect.Slice {
t = t.Elem()
}
var typeI = t
var ptr = false
if t.Kind() != reflect.Ptr {
typeI = reflect.PtrTo(t)
ptr = true
}
// This shouldn't be variadic.
if !variadic && typeI.Implements(typeICusP) {
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return &Argument{
String: fromUsager(t),
rtype: t,
pointer: ptr,
custom: CustomParser.CustomParse,
}, nil
}
// This shouldn't be variadic either.
if !variadic && typeI.Implements(typeIManP) {
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return &Argument{
String: fromUsager(t),
rtype: t,
pointer: ptr,
manual: ManualParser.ParseContent,
}, nil
}
if typeI.Implements(typeIParser) {
mt, ok := typeI.MethodByName("Parse")
if !ok {
panic("BUG: type IParser does not implement Parse")
}
avfn := func(input string) (reflect.Value, error) {
v := reflect.New(typeI.Elem())
ret := mt.Func.Call([]reflect.Value{
v, reflect.ValueOf(input),
})
_, err := errorReturns(ret)
if err != nil {
return nilV, err
}
if ptr {
v = v.Elem()
}
return v, nil
}
return &Argument{
String: fromUsager(typeI),
rtype: typeI,
pointer: ptr,
fn: avfn,
}, nil
}
var fn argumentValueFn
switch t.Kind() {
case reflect.String:
fn = func(s string) (reflect.Value, error) {
return reflect.ValueOf(s), nil
}
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fn = func(s string) (reflect.Value, error) {
i, err := strconv.ParseInt(s, 10, 64)
return quickRet(i, err, t)
}
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
fn = func(s string) (reflect.Value, error) {
u, err := strconv.ParseUint(s, 10, 64)
return quickRet(u, err, t)
}
case reflect.Float32, reflect.Float64:
fn = func(s string) (reflect.Value, error) {
f, err := strconv.ParseFloat(s, 64)
return quickRet(f, err, t)
}
case reflect.Bool:
fn = func(s string) (reflect.Value, error) {
switch s {
case "True", "TRUE", "true", "T", "t", "yes", "y", "Y", "1":
return reflect.ValueOf(true), nil
case "False", "FALSE", "false", "F", "f", "no", "n", "N", "0":
return reflect.ValueOf(false), nil
default:
return nilV, errors.New("invalid bool [true|false]")
}
}
}
if fn == nil {
return nil, errors.New("invalid type: " + t.String())
}
return &Argument{
String: fromUsager(t),
rtype: t,
fn: fn,
}, nil
}
func quickRet(v interface{}, err error, t reflect.Type) (reflect.Value, error) {
if err != nil {
return nilV, err
}
rv := reflect.ValueOf(v)
if t == nil {
return rv, nil
}
return rv.Convert(t), nil
}
func fromUsager(typeI reflect.Type) string {
if typeI.Implements(typeIUsager) {
mt, _ := typeI.MethodByName("Usage")
vs := mt.Func.Call([]reflect.Value{reflect.New(typeI).Elem()})
return vs[0].String()
}
s := strings.Split(typeI.String(), ".")
return s[len(s)-1]
}