package commands import ( "bytes" "errors" "sort" "strings" "unicode" "github.com/google/shlex" "git.sr.ht/~rjarry/aerc/config" "git.sr.ht/~rjarry/aerc/lib/state" "git.sr.ht/~rjarry/aerc/lib/templates" "git.sr.ht/~rjarry/aerc/log" "git.sr.ht/~rjarry/aerc/models" "git.sr.ht/~rjarry/aerc/widgets" ) type Command interface { Aliases() []string Execute(*widgets.Aerc, []string) error Complete(*widgets.Aerc, []string) []string } type OptionsProvider interface { Command Options() string } type OptionCompleter interface { OptionsProvider CompleteOption(*widgets.Aerc, rune, string) []string } type Commands map[string]Command func NewCommands() *Commands { cmds := Commands(make(map[string]Command)) return &cmds } func (cmds *Commands) dict() map[string]Command { return map[string]Command(*cmds) } func (cmds *Commands) Names() []string { names := make([]string, 0) for k := range cmds.dict() { names = append(names, k) } return names } func (cmds *Commands) ByName(name string) Command { if cmd, ok := cmds.dict()[name]; ok { return cmd } return nil } func (cmds *Commands) Register(cmd Command) { // TODO enforce unique aliases, until then, duplicate each if len(cmd.Aliases()) < 1 { return } for _, alias := range cmd.Aliases() { cmds.dict()[alias] = cmd } } type NoSuchCommand string func (err NoSuchCommand) Error() string { return "Unknown command " + string(err) } type CommandSource interface { Commands() *Commands } func templateData( aerc *widgets.Aerc, cfg *config.AccountConfig, msg *models.MessageInfo, ) models.TemplateData { var folder *models.Directory acct := aerc.SelectedAccount() if acct != nil { folder = acct.Directories().SelectedDirectory() } if cfg == nil && acct != nil { cfg = acct.AccountConfig() } if msg == nil && acct != nil { msg, _ = acct.SelectedMessage() } data := state.NewDataSetter() data.SetAccount(cfg) data.SetFolder(folder) data.SetInfo(msg, 0, false) if acct != nil { acct.SetStatus(func(s *state.AccountState, _ string) { data.SetState(s) }) } return data.Data() } func (cmds *Commands) ExecuteCommand( aerc *widgets.Aerc, origArgs []string, account *config.AccountConfig, msg *models.MessageInfo, ) error { if len(origArgs) == 0 { return errors.New("Expected a command.") } data := templateData(aerc, account, msg) args, err := expand(data, origArgs) if err != nil { return err } if cmd, ok := cmds.dict()[args[0]]; ok { log.Tracef("executing command %v", args) return cmd.Execute(aerc, args) } return NoSuchCommand(args[0]) } // expand expands template expressions and returns a new slice of arguments func expand(data models.TemplateData, origArgs []string) ([]string, error) { args := make([]string, len(origArgs)) copy(args, origArgs) c := strings.Join(origArgs, "") isTemplate := strings.Contains(c, "{{") || strings.Contains(c, "}}") if isTemplate { for i := range args { if strings.Contains(args[i], " ") { q := "\"" if strings.ContainsAny(args[i], "\"") { q = "'" } args[i] = q + args[i] + q } } cmdline := strings.Join(args, " ") log.Tracef("template data found in: %v", cmdline) t, err := templates.ParseTemplate("execute", cmdline) if err != nil { return nil, err } var buf bytes.Buffer err = templates.Render(t, &buf, data) if err != nil { return nil, err } args, err = splitCmd(buf.String()) if err != nil { return nil, err } } return args, nil } func GetTemplateCompletion( aerc *widgets.Aerc, cmd string, ) ([]string, string, bool) { args, err := splitCmd(cmd) if err != nil || len(args) == 0 { return nil, "", false } countLeft := strings.Count(cmd, "{{") if countLeft == 0 { return nil, "", false } countRight := strings.Count(cmd, "}}") switch { case countLeft > countRight: // complete template terms var i int for i = len(cmd) - 1; i >= 0; i-- { if strings.ContainsRune("{()| ", rune(cmd[i])) { break } } search, prefix := cmd[i+1:], cmd[:i+1] padding := strings.Repeat(" ", len(search)-len(strings.TrimLeft(search, " "))) options := FilterList( templates.Terms(), strings.TrimSpace(search), "", aerc.SelectedAccountUiConfig().FuzzyComplete, ) return options, prefix + padding, true case countLeft == countRight: // expand template data := templateData(aerc, nil, nil) t, err := templates.ParseTemplate("", cmd) if err != nil { log.Warnf("template parsing failed: %v", err) return nil, "", false } var sb strings.Builder if err = templates.Render(t, &sb, data); err != nil { log.Warnf("template rendering failed: %v", err) return nil, "", false } return []string{sb.String()}, "", true } return nil, "", false } // GetCompletions returns the completion options and the command prefix func (cmds *Commands) GetCompletions( aerc *widgets.Aerc, cmd string, ) (options []string, prefix string) { log.Tracef("completing command: %s", cmd) // start completion args, err := splitCmd(cmd) if err != nil { return } // nothing entered, list all commands if len(args) == 0 { options = cmds.Names() sort.Strings(options) return } // complete command name spaceTerminated := cmd[len(cmd)-1] == ' ' if len(args) == 1 && !spaceTerminated { for _, n := range cmds.Names() { options = append(options, n+" ") } options = CompletionFromList(aerc, options, args) return } // look for command in dictionary c, ok := cmds.dict()[args[0]] if !ok { return } // complete options var spec string if provider, ok := c.(OptionsProvider); ok { spec = provider.Options() } parser, err := newParser(cmd, spec, spaceTerminated) if err != nil { log.Debugf("completion parser failed: %v", err) return } switch parser.kind { case SHORT_OPTION: for _, r := range strings.ReplaceAll(spec, ":", "") { if strings.ContainsRune(parser.flag, r) { continue } option := string(r) if strings.Contains(spec, option+":") { option += " " } options = append(options, option) } prefix = cmd case OPTION_ARGUMENT: cmpl, ok := c.(OptionCompleter) if !ok { return } stem := cmd if parser.arg != "" { stem = strings.TrimSuffix(cmd, parser.arg) } pad := "" if !strings.HasSuffix(stem, " ") { pad += " " } s := parser.flag r := rune(s[len(s)-1]) for _, option := range cmpl.CompleteOption(aerc, r, parser.arg) { options = append(options, pad+escape(option)+" ") } prefix = stem case OPERAND: stem := strings.Join(args[:parser.optind], " ") for _, option := range c.Complete(aerc, args[1:]) { if strings.Contains(option, " ") { option = escape(option) } options = append(options, " "+option) } prefix = stem } return } func GetFolders(aerc *widgets.Aerc, args []string) []string { acct := aerc.SelectedAccount() if acct == nil { return make([]string, 0) } if len(args) == 0 { return acct.Directories().List() } return FilterList(acct.Directories().List(), args[0], "", acct.UiConfig().FuzzyComplete) } // CompletionFromList provides a convenience wrapper for commands to use in the // Complete function. It simply matches the items provided in valid func CompletionFromList(aerc *widgets.Aerc, valid []string, args []string) []string { if len(args) == 0 { return valid } return FilterList(valid, args[0], "", aerc.SelectedAccountUiConfig().FuzzyComplete) } func GetLabels(aerc *widgets.Aerc, args []string) []string { acct := aerc.SelectedAccount() if acct == nil { return make([]string, 0) } if len(args) == 0 { return acct.Labels() } // + and - are used to denote tag addition / removal and need to be striped // only the last tag should be completed, so that multiple labels can be // selected last := args[len(args)-1] others := strings.Join(args[:len(args)-1], " ") var prefix string switch last[0] { case '+': prefix = "+" case '-': prefix = "-" default: prefix = "" } trimmed := strings.TrimLeft(last, "+-") var prev string if len(others) > 0 { prev = others + " " } out := FilterList(acct.Labels(), trimmed, prev+prefix, acct.UiConfig().FuzzyComplete) return out } // hasCaseSmartPrefix checks whether s starts with prefix, using a case // sensitive match if and only if prefix contains upper case letters. func hasCaseSmartPrefix(s, prefix string) bool { if hasUpper(prefix) { return strings.HasPrefix(s, prefix) } return strings.HasPrefix(strings.ToLower(s), strings.ToLower(prefix)) } func hasUpper(s string) bool { for _, r := range s { if unicode.IsUpper(r) { return true } } return false } // splitCmd splits the command into arguments func splitCmd(cmd string) ([]string, error) { args, err := shlex.Split(cmd) if err != nil { return nil, err } return args, nil } func escape(s string) string { if strings.Contains(s, " ") { return strings.ReplaceAll(s, " ", "\\ ") } return s }