aerc/commands/commands.go

192 lines
4.1 KiB
Go
Raw Permalink Normal View History

2019-03-11 02:15:24 +01:00
package commands
import (
"errors"
"sort"
"strings"
"unicode"
2019-03-11 02:15:24 +01:00
2019-03-11 02:23:22 +01:00
"github.com/google/shlex"
"git.sr.ht/~rjarry/aerc/widgets"
2019-03-11 02:15:24 +01:00
)
type Command interface {
Aliases() []string
Execute(*widgets.Aerc, []string) error
Complete(*widgets.Aerc, []string) []string
}
2019-03-11 02:15:24 +01:00
type Commands map[string]Command
2019-03-11 02:15:24 +01:00
2019-03-21 21:30:23 +01:00
func NewCommands() *Commands {
cmds := Commands(make(map[string]Command))
2019-03-21 21:30:23 +01:00
return &cmds
}
func (cmds *Commands) dict() map[string]Command {
return map[string]Command(*cmds)
2019-03-21 21:30:23 +01:00
}
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
}
2019-03-21 21:30:23 +01:00
}
type NoSuchCommand string
func (err NoSuchCommand) Error() string {
return "Unknown command " + string(err)
}
type CommandSource interface {
Commands() *Commands
2019-03-11 02:15:24 +01:00
}
func (cmds *Commands) ExecuteCommand(aerc *widgets.Aerc, args []string) error {
2019-03-11 02:23:22 +01:00
if len(args) == 0 {
return errors.New("Expected a command.")
}
if cmd, ok := cmds.dict()[args[0]]; ok {
return cmd.Execute(aerc, args)
2019-03-11 02:15:24 +01:00
}
2019-03-21 21:30:23 +01:00
return NoSuchCommand(args[0])
2019-03-11 02:15:24 +01:00
}
func (cmds *Commands) GetCompletions(aerc *widgets.Aerc, cmd string) []string {
args, err := shlex.Split(cmd)
if err != nil {
return nil
}
// nothing entered, list all commands
if len(args) == 0 {
names := cmds.Names()
sort.Strings(names)
return names
}
// complete options
if len(args) > 1 || cmd[len(cmd)-1] == ' ' {
if cmd, ok := cmds.dict()[args[0]]; ok {
var completions []string
if len(args) > 1 {
completions = cmd.Complete(aerc, args[1:])
} else {
completions = cmd.Complete(aerc, []string{})
}
if completions != nil && len(completions) == 0 {
return nil
}
options := make([]string, 0)
for _, option := range completions {
options = append(options, args[0]+" "+option)
}
return options
}
return nil
}
// complete available commands
names := cmds.Names()
options := FilterList(names, args[0], "", aerc.SelectedAccountUiConfig().FuzzyComplete)
if len(options) > 0 {
return options
}
return nil
}
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)
}
2019-12-21 16:21:27 +01:00
func GetLabels(aerc *widgets.Aerc, args []string) []string {
acct := aerc.SelectedAccount()
if acct == nil {
return make([]string, 0)
}
2019-12-21 16:21:27 +01:00
if len(args) == 0 {
return acct.Labels()
2019-12-21 16:21:27 +01:00
}
// + 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 + " "
2019-12-21 16:21:27 +01:00
}
out := FilterList(acct.Labels(), trimmed, prev+prefix, acct.UiConfig().FuzzyComplete)
2019-12-21 16:21:27 +01:00
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
}