dcmd

Jun 27, 2024

Changes in this version

+ type ManualResponse struct

+ Messages []*discordgo.Message

+ func MarkManualResponse(responses []*discordgo.Message) ManualResponse

Mar 2, 2024

Changes in this version

type ArgDef

+ AutocompleteFunc func(data *Data, arg *ParsedArg) (choices []*discordgo.ApplicationCommandOptionChoice, err error)

+ Choices []*discordgo.ApplicationCommandOptionChoice

Nov 28, 2022

Changes in this version

type ParsedArg

+ func (p *ParsedArg) Float64() float64

May 13, 2022

Changes in this version

type AdvUserArg

+ func (u *AdvUserArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

type ArgType

+ CheckCompatibility func(def *ArgDef, part string) CompatibilityResult

type ChannelArg

+ func (ca *ChannelArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

+ type CompatibilityResult int

+ const CompatibilityGood

+ const CompatibilityPoor

+ const Incompatible

+ func DetermineSnowflakeCompatibility(s string) CompatibilityResult

+ func (c CompatibilityResult) String() string

type FloatArg

+ func (f *FloatArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

type IntArg

+ func (i *IntArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

type StringArg

+ func (s *StringArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

type UserArg

+ func (u *UserArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

type UserIDArg

+ func (u *UserIDArg) CheckCompatibility(def *ArgDef, part string) CompatibilityResult

May 5, 2022

Changes in this version

+ var AdvUser = &AdvUserArg

+ var AdvUserNoMember = &AdvUserArg

+ var ArgContainers = []rune

+ var BigInt = &IntArg

+ var Channel = &ChannelArg

+ var ChannelOrThread = &ChannelArg

+ var CmdNameRegex = regexp.MustCompile(`^[\w-]{1,32}$`)

+ var CustomUsernameSearchFunc func(state dstate.StateTracker, gs *dstate.GuildSet, query string) (*dstate.MemberState, error)

+ var ErrChannelNotFound = errors.New("Channel not found")

+ var ErrGuildNotFound = errors.New("Guild not found")

+ var ErrMemberNotAvailable = errors.New("Member not provided in message")

+ var ErrMemberNotAvailableInteraction = errors.New("Member not provided in interaction")

+ var ErrNoComboFound = NewSimpleUserError("No matching combo found")

+ var ErrNotEnoughArguments = NewSimpleUserError("Not enough arguments passed")

+ var Float = &FloatArg

+ var Int = &IntArg

+ var String = &StringArg

+ var User = &UserArg

+ var UserID = &UserIDArg

+ var UserReqMention = &UserArg

+ func FindCombo(defs []*ArgDef, combos [][]int, args []*RawArg) (combo []int, ok bool)

+ func FindDiscordMemberByName(state dstate.StateTracker, gs *dstate.GuildSet, str string) (*dstate.MemberState, error)

+ func GenerateHelp(d *Data, container *Container, formatter HelpFormatter) (embeds []*discordgo.MessageEmbed)

+ func GenerateTargettedHelp(target string, d *Data, container *Container, formatter HelpFormatter) (embeds []*discordgo.MessageEmbed)

+ func Indent(depth int) string

+ func IsUserError(err error) bool

+ func NewErrArgExpected(name string, expected string, got interface{}) error

+ func NewSimpleUserError(args ...interface{}) error

+ func ParseArgDefs(defs []*ArgDef, required int, combos [][]int, data *Data, split []*RawArg) error

+ func ParseCmdArgs(data *Data) error

+ func ParseCmdArgsFromInteraction(data *Data) error

+ func ParseCmdArgsFromMessage(data *Data) error

+ func RuneByIndex(s string, runePos int) (rune, int)

+ func SendResponseInterface(data *Data, reply interface{}, escapeEveryoneMention bool) ([]*discordgo.Message, error)

+ func SortInteractionOptions(data *Data) []*sortedInteractionArg

+ func SplitSendMessage(data *Data, contents string, allowedMentions discordgo.AllowedMentions) ([]*discordgo.Message, error)

+ func SplitString(s string, maxLen int) []string

+ func StrSplitNext(s string, runeCount int) (split, rest string)

+ func ValidateCommand(cmd Cmd, trigger *Trigger) error

+ func ValidateCommandPanic(cmd Cmd, trigger *Trigger)

+ type AdvUserArg struct

+ EnableUserID bool

+ EnableUsernameSearch bool

+ RequireMembership bool

+ func (u *AdvUserArg) HelpName() string

+ func (u *AdvUserArg) Matches(def *ArgDef, part string) bool

+ func (u *AdvUserArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (u *AdvUserArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (u *AdvUserArg) ParseMention(def *ArgDef, part string, data *Data) (user *discordgo.User)

+ func (u *AdvUserArg) SearchID(parsed int64, data *Data) (member *dstate.MemberState, user *discordgo.User)

+ func (u *AdvUserArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type AdvUserMatch struct

+ Member *dstate.MemberState

+ User *discordgo.User

+ func (a *AdvUserMatch) UsernameOrNickname() string

+ type ArgDef struct

+ Default interface{}

+ Help string

+ Name string

+ Type ArgType

+ func (def *ArgDef) NewParsedDef() *ParsedArg

+ func (def *ArgDef) StandardSlashCommandOption(typ discordgo.ApplicationCommandOptionType) *discordgo.ApplicationCommandOption

+ type ArgType interface

+ HelpName func() string

+ Matches func(def *ArgDef, part string) bool

+ ParseFromInteraction func(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ ParseFromMessage func(def *ArgDef, part string, data *Data) (val interface{}, err error)

+ SlashCommandOptions func(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type Category struct

+ Description string

+ EmbedColor int

+ HelpEmoji string

+ Name string

+ type ChannelArg struct

+ AllowThreads bool

+ func (ca *ChannelArg) HelpName() string

+ func (ca *ChannelArg) Matches(def *ArgDef, part string) bool

+ func (ca *ChannelArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (ca *ChannelArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (ca *ChannelArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type ChannelNotFound struct

+ ID int64

+ func (c *ChannelNotFound) Error() string

+ func (c *ChannelNotFound) IsUserError() bool

+ type Cmd interface

+ Run func(data *Data) (interface{}, error)

+ type CmdDescArgDefs interface

+ type CmdWithArgDefs interface

+ ArgDefs func(data *Data) (args []*ArgDef, required int, combos [][]int)

+ type CmdWithCanUse interface

+ CanUse func(data *Data) (bool, error)

+ type CmdWithCategory interface

+ Category func() *Category

+ type CmdWithCustomParser interface

+ Parse func(stripped string, data *Data) (*Data, error)

+ type CmdWithDescriptions interface

+ Descriptions func(data *Data) (short, long string)

+ type CmdWithSwitches interface

+ Switches func() []*ArgDef

+ type Container struct

+ Category string

+ Commands []*RegisteredCommand

+ DMNotFound RunFunc

+ DefaultMention RunFunc

+ Description string

+ HelpColor int

+ HelpOwnEmbed bool

+ HelpTitleEmoji string

+ IgnoreBots bool

+ LongDescription string

+ Names []string

+ NotFound RunFunc

+ Parent *Container

+ RunInDM bool

+ SendError bool

+ SendStackOnPanic bool

+ func (c *Container) AbsFindCommand(searchStr string) (cmd *RegisteredCommand, container *Container)

+ func (c *Container) AbsFindCommandWithRest(searchStr string) (cmd *RegisteredCommand, container *Container, rest string)

+ func (c *Container) AddCommand(cmd Cmd, trigger *Trigger) *RegisteredCommand

+ func (c *Container) AddMidlewares(mw ...MiddleWareFunc)

+ func (c *Container) BuildMiddlewareChain(r RunFunc, cmd *RegisteredCommand) RunFunc

+ func (c *Container) BuildMiddlewareChains(containerChain []*Container)

+ func (c *Container) Descriptions(data *Data) (string, string)

+ func (c *Container) FindCommand(searchStr string) (cmd *RegisteredCommand, rest string)

+ func (c *Container) FullName(aliases bool) string

+ func (c *Container) Run(data *Data) (interface{}, error)

+ func (c *Container) Sub(mainName string, aliases ...string) (*Container, *Trigger)

+ type Data struct

+ Args []*ParsedArg

+ Author *discordgo.User

+ ChannelID int64

+ Cmd *RegisteredCommand

+ ContainerChain []*Container

+ GuildData *GuildContextData

+ Session *discordgo.Session

+ SlashCommandTriggerData *SlashCommandTriggerData

+ Source TriggerSource

+ Switches map[string]*ParsedArg

+ System *System

+ TraditionalTriggerData *TraditionalTriggerData

+ TriggerType TriggerType

+ func (d *Data) Context() context.Context

+ func (d *Data) SendFollowupMessage(reply interface{}, allowedMentions discordgo.AllowedMentions) ([]*discordgo.Message, error)

+ func (d *Data) Switch(name string) *ParsedArg

+ func (d *Data) WithContext(ctx context.Context) *Data

+ type ErrArgExpectedType struct

+ Expected string

+ Got string

+ Name string

+ func (e *ErrArgExpectedType) Error() string

+ func (e *ErrArgExpectedType) IsUserError() bool

+ type ErrResolvedNotFound struct

+ ID int64

+ Key string

+ Type string

+ func (r *ErrResolvedNotFound) Error() string

+ func (r *ErrResolvedNotFound) IsUserError() bool

+ type FloatArg struct

+ Max float64

+ Min float64

+ func (f *FloatArg) HelpName() string

+ func (f *FloatArg) Matches(def *ArgDef, part string) bool

+ func (f *FloatArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (f *FloatArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (f *FloatArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type GuildContextData struct

+ CS *dstate.ChannelState

+ GS *dstate.GuildSet

+ MS *dstate.MemberState

+ type HelpFormatter interface

+ FullCmdHelp func(cmd *RegisteredCommand, container *Container, data *Data) *discordgo.MessageEmbed

+ ShortCmdHelp func(cmd *RegisteredCommand, container *Container, data *Data) string

+ type ImproperMention struct

+ Part string

+ func (i *ImproperMention) Error() string

+ func (i *ImproperMention) IsUserError() bool

+ type IntArg struct

+ InteractionString bool

+ Max int64

+ Min int64

+ func (i *IntArg) HelpName() string

+ func (i *IntArg) Matches(def *ArgDef, part string) bool

+ func (i *IntArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (i *IntArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (i *IntArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type InvalidFloat struct

+ Part string

+ func (i *InvalidFloat) Error() string

+ func (i *InvalidFloat) IsUserError() bool

+ type InvalidInt struct

+ Part string

+ func (i *InvalidInt) Error() string

+ func (i *InvalidInt) IsUserError() bool

+ type MiddleWareFunc func(next RunFunc) RunFunc

+ type NoMention struct

+ Part string

+ func (i *NoMention) Error() string

+ func (i *NoMention) IsUserError() bool

+ type OutOfRangeError struct

+ ArgName string

+ Float bool

+ Got interface{}

+ Max interface{}

+ Min interface{}

+ func (o *OutOfRangeError) Error() string

+ func (o *OutOfRangeError) IsUserError() bool

+ type ParsedArg struct

+ Def *ArgDef

+ Raw *RawArg

+ Value interface{}

+ func NewParsedArgs(defs []*ArgDef) []*ParsedArg

+ func (p *ParsedArg) AdvUser() *AdvUserMatch

+ func (p *ParsedArg) Bool() bool

+ func (p *ParsedArg) Int() int

+ func (p *ParsedArg) Int64() int64

+ func (p *ParsedArg) MemberState() *dstate.MemberState

+ func (p *ParsedArg) Str() string

+ func (p *ParsedArg) User() *discordgo.User

+ type PrefixProvider interface

+ Prefix func(data *Data) string

+ func NewSimplePrefixProvider(prefix string) PrefixProvider

+ type RawArg struct

+ Container rune

+ Str string

+ func ParseSwitches(switches []*ArgDef, data *Data, split []*RawArg) ([]*RawArg, error)

+ func SplitArgs(in string) []*RawArg

+ type RegisteredCommand struct

+ Command Cmd

+ Trigger *Trigger

+ func (r *RegisteredCommand) FormatNames(includeAliases bool, seperator string) string

+ type Response interface

+ Send func(data *Data) ([]*discordgo.Message, error)

+ type ResponseSender interface

+ SendResponse func(cmdData *Data, resp interface{}, err error) error

+ type RunFunc func(data *Data) (interface{}, error)

+ func ArgParserMW(inner RunFunc) RunFunc

+ type SimpleCmd struct

+ ArgDefCombos [][]int

+ CmdArgDefs []*ArgDef

+ CmdSwitches []*ArgDef

+ LongDesc string

+ RequiredArgDefs int

+ RunFunc func(data *Data) (interface{}, error)

+ ShortDesc string

+ func (s *SimpleCmd) ArgDefs(data *Data) (args []*ArgDef, required int, combos [][]int)

+ func (s *SimpleCmd) Descriptions(data *Data) (short, long string)

+ func (s *SimpleCmd) Run(data *Data) (interface{}, error)

+ func (s *SimpleCmd) Switches() []*ArgDef

+ type SimplePrefixProvider struct

+ func (pp *SimplePrefixProvider) Prefix(d *Data) string

+ type SlashCommandTriggerData struct

+ Interaction *discordgo.Interaction

+ Options []*discordgo.ApplicationCommandInteractionDataOption

+ type SlashCommandsParseOptions struct

+ Interaction *discordgo.Interaction

+ Options map[string]*discordgo.ApplicationCommandInteractionDataOption

+ func (sopts *SlashCommandsParseOptions) ExpectAny(name string) (interface{}, error)

+ func (sopts *SlashCommandsParseOptions) ExpectAnyOpt(name string) (interface{}, bool)

+ func (sopts *SlashCommandsParseOptions) ExpectBool(name string) (bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectBoolOpt(name string) (bool, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectChannel(name string) (*discordgo.Channel, error)

+ func (sopts *SlashCommandsParseOptions) ExpectChannelOpt(name string) (*discordgo.Channel, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectInt64(name string) (int64, error)

+ func (sopts *SlashCommandsParseOptions) ExpectInt64Opt(name string) (int64, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectMember(name string) (*discordgo.Member, error)

+ func (sopts *SlashCommandsParseOptions) ExpectMemberOpt(name string) (*discordgo.Member, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectRole(name string) (*discordgo.Role, error)

+ func (sopts *SlashCommandsParseOptions) ExpectRoleOpt(name string) (*discordgo.Role, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectString(name string) (string, error)

+ func (sopts *SlashCommandsParseOptions) ExpectStringOpt(name string) (string, bool, error)

+ func (sopts *SlashCommandsParseOptions) ExpectUser(name string) (*discordgo.User, error)

+ func (sopts *SlashCommandsParseOptions) ExpectUserOpt(name string) (*discordgo.User, bool, error)

+ type SortedCommandEntry struct

+ Cmd *RegisteredCommand

+ Container *Container

+ type SortedCommandSet struct

+ Category *Category

+ Commands []*SortedCommandEntry

+ Container *Container

+ func FindSortedCommands(sets []*SortedCommandSet, cat *Category, container *Container) *SortedCommandSet

+ func SortCommands(closestGroupContainer *Container, cmdContainer *Container) []*SortedCommandSet

+ func (s *SortedCommandSet) Color() int

+ func (s *SortedCommandSet) Emoji() string

+ func (s *SortedCommandSet) Name() string

+ type StdHelpCommand struct

+ Formatter HelpFormatter

+ SendFullInDM bool

+ SendTargettedInDM bool

+ func NewStdHelpCommand() *StdHelpCommand

+ func (h *StdHelpCommand) ArgDefs(data *Data) (args []*ArgDef, required int, combos [][]int)

+ func (h *StdHelpCommand) Descriptions(data *Data) (string, string)

+ func (h *StdHelpCommand) Run(d *Data) (interface{}, error)

+ type StdHelpFormatter struct

+ func (s *StdHelpFormatter) ArgDef(arg *ArgDef) (str string)

+ func (s *StdHelpFormatter) ArgDefLine(argDefs []*ArgDef, required int) (str string)

+ func (s *StdHelpFormatter) ArgDefs(cmd *RegisteredCommand, data *Data) (str string)

+ func (s *StdHelpFormatter) CmdNameString(cmd *RegisteredCommand, container *Container, containerAliases bool) string

+ func (s *StdHelpFormatter) FullCmdHelp(cmd *RegisteredCommand, container *Container, data *Data) *discordgo.MessageEmbed

+ func (s *StdHelpFormatter) ShortCmdHelp(cmd *RegisteredCommand, container *Container, data *Data) string

+ func (s *StdHelpFormatter) Switches(cmd Cmd) (str string)

+ type StdResponseSender struct

+ LogErrors bool

+ func (s *StdResponseSender) SendResponse(cmdData *Data, resp interface{}, err error) error

+ type StringArg struct

+ func (s *StringArg) HelpName() string

+ func (s *StringArg) Matches(def *ArgDef, part string) bool

+ func (s *StringArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (s *StringArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (s *StringArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type System struct

+ Prefix PrefixProvider

+ ResponseSender ResponseSender

+ Root *Container

+ State dstate.StateTracker

+ func NewStandardSystem(staticPrefix string) (system *System)

+ func (sys *System) CheckInteraction(s *discordgo.Session, interaction *discordgo.Interaction) error

+ func (sys *System) CheckMessage(s *discordgo.Session, m *discordgo.MessageCreate) error

+ func (sys *System) CheckMessageWtihPrefetchedPrefix(s *discordgo.Session, m *discordgo.MessageCreate, prefetchedPrefix string) error

+ func (sys *System) FillDataInteraction(s *discordgo.Session, interaction *discordgo.Interaction) (*Data, error)

+ func (sys *System) FillDataLegacyMessage(s *discordgo.Session, m *discordgo.Message) (*Data, error)

+ func (sys *System) FindMentionPrefix(data *Data) (found bool)

+ func (sys *System) FindPrefix(data *Data) (found bool)

+ func (sys *System) FindPrefixWithPrefetched(data *Data, commandPrefix string) (found bool)

+ func (sys *System) HandleMessageCreate(s *discordgo.Session, m *discordgo.MessageCreate)

+ type TemporaryResponse struct

+ Duration time.Duration

+ EscapeEveryone bool

+ Response interface{}

+ func NewTemporaryResponse(d time.Duration, inner interface{}, escapeEveryoneMention bool) *TemporaryResponse

+ func (t *TemporaryResponse) Send(data *Data) ([]*discordgo.Message, error)

+ type TraditionalTriggerData struct

+ Message *discordgo.Message

+ MessageStrippedPrefix string

+ PrefixUsed string

+ type Trigger struct

+ EnableInDM bool

+ EnableInGuildChannels bool

+ EnableInThreads bool

+ HideFromHelp bool

+ Middlewares []MiddleWareFunc

+ Names []string

+ func NewTrigger(name string, aliases ...string) *Trigger

+ func (t *Trigger) SetEnableInDM(enable bool) *Trigger

+ func (t *Trigger) SetEnableInGuildChannels(enable bool) *Trigger

+ func (t *Trigger) SetEnabledInThreads(enable bool) *Trigger

+ func (t *Trigger) SetHideFromHelp(hide bool) *Trigger

+ func (t *Trigger) SetMiddlewares(mw ...MiddleWareFunc) *Trigger

+ type TriggerSource int

+ const TriggerSourceDM

+ const TriggerSourceGuild

+ type TriggerType int

+ const TriggerTypeDirect

+ const TriggerTypeMention

+ const TriggerTypePrefix

+ const TriggerTypeSlashCommands

+ type UserArg struct

+ RequireMention bool

+ func (u *UserArg) HelpName() string

+ func (u *UserArg) Matches(def *ArgDef, part string) bool

+ func (u *UserArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (u *UserArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (u *UserArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type UserError interface

+ IsUserError func() bool

+ type UserIDArg struct

+ func (u *UserIDArg) HelpName() string

+ func (u *UserIDArg) Matches(def *ArgDef, part string) bool

+ func (u *UserIDArg) ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

+ func (u *UserIDArg) ParseFromMessage(def *ArgDef, part string, data *Data) (interface{}, error)

+ func (u *UserIDArg) SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption

+ type UserNotFound struct

+ Part string

+ func (i *UserNotFound) Error() string

+ func (i *UserNotFound) IsUserError() bool