package bot import ( "reflect" ) type command struct { value reflect.Value // Func event reflect.Type isInterface bool } func newCommand(value reflect.Value, event reflect.Type) command { return command{ value: value, event: event, isInterface: event.Kind() == reflect.Interface, } } func (c *command) isEvent(t reflect.Type) bool { return (!c.isInterface && c.event == t) || (c.isInterface && t.Implements(c.event)) } func (c *command) call(arg0 interface{}, argv ...reflect.Value) (interface{}, error) { return callWith(c.value, arg0, argv...) } func callWith(caller reflect.Value, arg0 interface{}, argv ...reflect.Value) (interface{}, error) { var callargs = make([]reflect.Value, 0, 1+len(argv)) if v, ok := arg0.(reflect.Value); ok { callargs = append(callargs, v) } else { callargs = append(callargs, reflect.ValueOf(arg0)) } callargs = append(callargs, argv...) return errorReturns(caller.Call(callargs)) } type caller interface { call(arg0 interface{}, argv ...reflect.Value) (interface{}, error) } func errorReturns(returns []reflect.Value) (interface{}, error) { // Handlers may return nothing. if len(returns) == 0 { return nil, nil } // assume first return is always error, since we checked for this in // parseCommands. v := returns[len(returns)-1].Interface() // If the last return (error) is nil. if v == nil { // If we only have 1 returns, that return must be the error. The error // is nil, so nil is returned. if len(returns) == 1 { return nil, nil } // Return the first argument as-is. The above returns[-1] check assumes // 2 return values (T, error), meaning returns[0] is the T value. return returns[0].Interface(), nil } // Treat the last return as an error. return nil, v.(error) } // MethodContext 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 MethodContext struct { command method reflect.Method // extend middlewares []*MiddlewareContext Description string // MethodName is the name of the method. This field should NOT be changed. MethodName string // Command is the Discord command used to call the method. Command string // hidden if empty // Hidden is true if the method has a hidden nameflag. // Hidden bool // Variadic is true if the function is a variadic one or if the last // argument accepts multiple strings. Variadic bool Arguments []Argument } func parseMethod(value reflect.Value, method reflect.Method) *MethodContext { methodT := value.Type() numArgs := methodT.NumIn() if numArgs == 0 { // Doesn't meet the requirement for an event, continue. return nil } // Check number of returns: numOut := methodT.NumOut() // Returns can either be: // Nothing - func() // An error - func() error // An error and something else - func() (T, error) if numOut > 2 { return nil } // Check the last return's type if the method returns anything. if numOut > 0 { if i := methodT.Out(numOut - 1); i == nil || !i.Implements(typeIError) { // Invalid, skip. return nil } } var command = MethodContext{ command: newCommand(value, methodT.In(0)), method: method, MethodName: method.Name, Variadic: methodT.IsVariadic(), } // Only set the command name if it's a MessageCreate handler. if command.event == typeMessageCreate { command.Command = lowerFirstLetter(command.method.Name) } if numArgs > 1 { // Event handlers that aren't MessageCreate should not have arguments. if command.event != typeMessageCreate { return nil } // If the event type is messageCreate: command.Arguments = make([]Argument, 0, numArgs-1) // Fill up arguments. This should work with cusP and manP for i := 1; i < numArgs; i++ { t := methodT.In(i) a, err := newArgument(t, command.Variadic) if err != nil { panic("Error parsing argument " + t.String() + ": " + err.Error()) } command.Arguments = append(command.Arguments, *a) // We're done if the type accepts multiple arguments. if a.custom != nil || a.manual != nil { command.Variadic = true // treat as variadic break } } } return &command } func (cctx *MethodContext) addMiddleware(mw *MiddlewareContext) { cctx.middlewares = append(cctx.middlewares, mw) } func (cctx *MethodContext) walkMiddlewares(ev reflect.Value) error { for _, mw := range cctx.middlewares { _, err := mw.call(ev) if err != nil { return err } } return nil } func (cctx *MethodContext) 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 } // SetName sets the command name. func (cctx *MethodContext) SetName(name string) { cctx.Command = name } type MiddlewareContext struct { command } // ParseMiddleware parses a middleware function. This function panics. func ParseMiddleware(mw interface{}) *MiddlewareContext { value := reflect.ValueOf(mw) methodT := value.Type() numArgs := methodT.NumIn() if numArgs != 1 { panic("Invalid argument signature for " + methodT.String()) } // Check number of returns: numOut := methodT.NumOut() // Returns can either be: // Nothing - func() // An error - func() error if numOut > 1 { panic("Invalid return signature for " + methodT.String()) } // Check the last return's type if the method returns anything. if numOut == 1 { if i := methodT.Out(0); i == nil || !i.Implements(typeIError) { panic("Unexpected return type (not error) for " + methodT.String()) } } var middleware = MiddlewareContext{ command: newCommand(value, methodT.In(0)), } return &middleware }