Since panics still regularly "destroy" the terminal, it is hard to get a stack trace for panics you do not anticipate. This commit adds a panic handler that automatically creates a logfile inside the current working directory. It has to be added to every goroutine that is started and will repair the terminal on a panic. Signed-off-by: Moritz Poldrack <git@moritz.sh> Acked-by: Robin Jarry <robin@jarry.cc>
220 lines
4.4 KiB
Go
220 lines
4.4 KiB
Go
package commands
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/lithammer/fuzzysearch/fuzzy"
|
|
|
|
"git.sr.ht/~rjarry/aerc/lib"
|
|
"git.sr.ht/~rjarry/aerc/logging"
|
|
"git.sr.ht/~rjarry/aerc/models"
|
|
"git.sr.ht/~rjarry/aerc/widgets"
|
|
"github.com/gdamore/tcell/v2"
|
|
"github.com/mitchellh/go-homedir"
|
|
)
|
|
|
|
// QuickTerm is an ephemeral terminal for running a single command and quitting.
|
|
func QuickTerm(aerc *widgets.Aerc, args []string, stdin io.Reader) (*widgets.Terminal, error) {
|
|
cmd := exec.Command(args[0], args[1:]...)
|
|
pipe, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
term, err := widgets.NewTerminal(cmd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
term.OnClose = func(err error) {
|
|
if err != nil {
|
|
aerc.PushError(err.Error())
|
|
// remove the tab on error, otherwise it gets stuck
|
|
aerc.RemoveTab(term)
|
|
} else {
|
|
aerc.PushStatus("Process complete, press any key to close.",
|
|
10*time.Second)
|
|
term.OnEvent = func(event tcell.Event) bool {
|
|
aerc.RemoveTab(term)
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
term.OnStart = func() {
|
|
status := make(chan error, 1)
|
|
|
|
go func() {
|
|
defer logging.PanicHandler()
|
|
|
|
_, err := io.Copy(pipe, stdin)
|
|
defer pipe.Close()
|
|
status <- err
|
|
}()
|
|
|
|
err := <-status
|
|
if err != nil {
|
|
aerc.PushError(err.Error())
|
|
}
|
|
}
|
|
|
|
return term, nil
|
|
}
|
|
|
|
// CompletePath provides filesystem completions given a starting path.
|
|
func CompletePath(path string) []string {
|
|
if path == "" {
|
|
// default to cwd
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
path = cwd
|
|
}
|
|
|
|
path, err := homedir.Expand(path)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
// strip trailing slashes, etc.
|
|
path = filepath.Clean(path)
|
|
|
|
if _, err := os.Stat(path); os.IsNotExist(err) {
|
|
// if the path doesn't exist, it is likely due to it being a partial path
|
|
// in this case, we want to return possible matches (ie /hom* should match
|
|
// /home)
|
|
matches, err := filepath.Glob(fmt.Sprintf("%s*", path))
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
|
|
for i, m := range matches {
|
|
if isDir(m) {
|
|
matches[i] = m + "/"
|
|
}
|
|
}
|
|
|
|
sort.Strings(matches)
|
|
return matches
|
|
}
|
|
|
|
files := listDir(path, false)
|
|
|
|
for i, f := range files {
|
|
f = filepath.Join(path, f)
|
|
if isDir(f) {
|
|
f += "/"
|
|
}
|
|
|
|
files[i] = f
|
|
}
|
|
|
|
sort.Strings(files)
|
|
return files
|
|
}
|
|
|
|
func isDir(path string) bool {
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
return info.IsDir()
|
|
}
|
|
|
|
// return all filenames in a directory, optionally including hidden files
|
|
func listDir(path string, hidden bool) []string {
|
|
f, err := os.Open(path)
|
|
if err != nil {
|
|
return []string{}
|
|
}
|
|
|
|
files, err := f.Readdirnames(-1) // read all dir names
|
|
if err != nil {
|
|
return []string{}
|
|
}
|
|
|
|
if hidden {
|
|
return files
|
|
}
|
|
|
|
var filtered []string
|
|
for _, g := range files {
|
|
if !strings.HasPrefix(g, ".") {
|
|
filtered = append(filtered, g)
|
|
}
|
|
}
|
|
|
|
return filtered
|
|
}
|
|
|
|
// MarkedOrSelected returns either all marked messages if any are marked or the
|
|
// selected message instead
|
|
func MarkedOrSelected(pm widgets.ProvidesMessages) ([]uint32, error) {
|
|
// marked has priority over the selected message
|
|
marked, err := pm.MarkedMessages()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(marked) > 0 {
|
|
return marked, nil
|
|
}
|
|
msg, err := pm.SelectedMessage()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return []uint32{msg.Uid}, nil
|
|
}
|
|
|
|
// UidsFromMessageInfos extracts a uid slice from a slice of MessageInfos
|
|
func UidsFromMessageInfos(msgs []*models.MessageInfo) []uint32 {
|
|
uids := make([]uint32, len(msgs))
|
|
i := 0
|
|
for _, msg := range msgs {
|
|
uids[i] = msg.Uid
|
|
i++
|
|
}
|
|
return uids
|
|
}
|
|
|
|
func MsgInfoFromUids(store *lib.MessageStore, uids []uint32) ([]*models.MessageInfo, error) {
|
|
infos := make([]*models.MessageInfo, len(uids))
|
|
for i, uid := range uids {
|
|
var ok bool
|
|
infos[i], ok = store.Messages[uid]
|
|
if !ok {
|
|
return nil, fmt.Errorf("uid not found")
|
|
}
|
|
if infos[i] == nil {
|
|
return nil, fmt.Errorf("message store not ready yet")
|
|
}
|
|
}
|
|
return infos, nil
|
|
}
|
|
|
|
// FilterList takes a list of valid completions and filters it, either
|
|
// by case smart prefix, or by fuzzy matching, prepending "prefix" to each completion
|
|
func FilterList(valid []string, search, prefix string, isFuzzy bool) []string {
|
|
out := make([]string, 0)
|
|
if isFuzzy {
|
|
for _, v := range fuzzy.RankFindFold(search, valid) {
|
|
out = append(out, prefix+v.Target)
|
|
}
|
|
} else {
|
|
for _, v := range valid {
|
|
if hasCaseSmartPrefix(v, search) {
|
|
out = append(out, prefix+v)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|