tools

tui.go (7407B)

---

 package main
 
 import (
 	"cmp"
 	"fmt"
 	"os"
 	"os/exec"
 	"os/signal"
 	"runtime"
 	"sort"
 	"strings"
 	"syscall"
 	"unicode/utf8"
 	"unsafe"
 )
 
 // Terminal state is saved once, in enter(); later transitions only flip raw mode
 const (
 	altOn  = "\x1b[?1049h\x1b[?25l" // alt screen, hide cursor
 	altOff = "\x1b[?25h\x1b[?1049l" // show cursor, primary screen
 )
 
 func (a *app) enter() {
 	cmd := exec.Command("stty", "-g")
 	cmd.Stdin = os.Stdin
 	if out, err := cmd.Output(); err == nil {
 		a.savedStty = strings.TrimSpace(string(out))
 	}
 	a.resume()
 }
 
 func (a *app) resume() { a.raw(); fmt.Print(altOn) }
 func (a *app) leave()  { fmt.Print(altOff); a.cooked() }
 
 // raw disables isig/ixon too, so ctrl-c/s/q arrive as bytes instead of signals
 func (a *app) raw() { a.stty("-echo", "-icanon", "-isig", "-ixon", "min", "1", "time", "0") }
 
 func (a *app) cooked() { a.stty(cmp.Or(a.savedStty, "sane")) }
 
 func (a *app) stty(args ...string) {
 	cmd := exec.Command("stty", args...)
 	cmd.Stdin = os.Stdin
 	_ = cmd.Run()
 }
 
 // size queries the window via ioctl
 func (a *app) size() {
 	var ws struct{ row, col, x, y uint16 }
 	_, _, _ = syscall.Syscall(syscall.SYS_IOCTL, os.Stdin.Fd(),
 		uintptr(syscall.TIOCGWINSZ), uintptr(unsafe.Pointer(&ws)))
 	a.rows = max(int(ws.row), 5)
 	a.cols = max(int(ws.col), 20)
 }
 
 func (a *app) run() {
 	sort.SliceStable(a.docs, func(i, j int) bool {
 		return a.docs[i].mtime.After(a.docs[j].mtime)
 	})
 	a.enter()
 	defer a.leave()
 
 	// defer does not run on signal death; restore the terminal by hand
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM, syscall.SIGHUP)
 	go func() { <-sig; a.leave(); os.Exit(1) }()
 
 	a.size()
 	a.search()
 	a.draw()
 
 	buf := make([]byte, 64)
 	for {
 		n, err := os.Stdin.Read(buf)
 		if err != nil || n == 0 {
 			return
 		}
 		if a.handle(buf[:n]) {
 			return
 		}
 		a.draw()
 	}
 }
 
 func (a *app) handle(b []byte) bool {
 	changed := false
 	for i := 0; i < len(b); {
 		c := b[i]
 		switch {
 		case c == 0x1b: // CSI sequence; a lone esc quits; ignore alt/partial
 			if i+1 < len(b) && b[i+1] == '[' {
 				j := i + 2
 				for j < len(b) && (b[j] < 0x40 || b[j] > 0x7e) {
 					j++
 				}
 				if j < len(b) {
 					switch param, final := string(b[i+2:j]), b[j]; {
 					case final == 'A':
 						a.move(-1)
 					case final == 'B':
 						a.move(1)
 					case final == '~' && param == "5":
 						a.move(-(a.rows - 2))
 					case final == '~' && param == "6":
 						a.move(a.rows - 2)
 					}
 					i = j + 1
 					continue
 				}
 			}
 			if len(b) == 1 {
 				return true
 			}
 			// alt-prefixed key or a split escape: drop the esc, keep going
 		case c == 3: // ctrl-c
 			return true
 		case c == 9: // tab
 			a.content = !a.content
 			changed = true
 		case c == 13 || c == 10: // enter
 			a.open()
 		case c == 15: // ctrl-o
 			a.openURL()
 		case c == 25: // ctrl-y
 			a.yank()
 		case c == 14: // ctrl-n
 			a.move(1)
 		case c == 16: // ctrl-p
 			a.move(-1)
 		case c == 21: // ctrl-u
 			a.query = a.query[:0]
 			changed = true
 		case c == 127 || c == 8: // backspace
 			if len(a.query) > 0 {
 				a.query = a.query[:len(a.query)-1]
 				changed = true
 			}
 		case c < 32:
 		default:
 			r, n := utf8.DecodeRune(b[i:])
 			if r == utf8.RuneError && n <= 1 {
 				i++ // invalid or a multibyte rune split across reads
 				continue
 			}
 			if r >= 32 && r != 0x7f {
 				a.query = append(a.query, r)
 				changed = true
 			}
 			i += n
 			continue
 		}
 		i++
 	}
 	if changed {
 		a.search()
 	}
 	return false
 }
 
 func (a *app) move(d int) {
 	if len(a.results) > 0 {
 		a.sel = max(0, min(a.sel+d, len(a.results)-1))
 	}
 }
 
 // cur returns the selected match, or false if there is none
 func (a *app) cur() (match, bool) {
 	if a.sel < len(a.results) {
 		return a.results[a.sel], true
 	}
 	return match{}, false
 }
 
 func (a *app) draw() {
 	a.size()
 	listH := a.rows - 1
 	leftW := min(max(a.cols*2/5, 24), a.cols-10)
 	prevW := a.cols - leftW - 1
 
 	if a.sel < a.top {
 		a.top = a.sel
 	}
 	if a.sel >= a.top+listH {
 		a.top = a.sel - listH + 1
 	}
 
 	var sb strings.Builder
 	sb.WriteString("\x1b[H\x1b[2J")
 
 	mode := "content"
 	if !a.content {
 		mode = "browse"
 	}
 	qTrunc := truncate(string(a.query), a.cols/2)
 	prompt := fmt.Sprintf("\x1b[1m%s\x1b[0m ▸ %s", mode, qTrunc)
 	count := fmt.Sprintf("\x1b[2m%d/%d\x1b[0m", min(len(a.results), a.sel+1), len(a.results))
 	sb.WriteString(pad(prompt, a.cols-visLen(count)))
 	sb.WriteString(count)
 	sb.WriteString("\r\n")
 
 	prev := a.previewLines(prevW, listH)
 	for i := range listH {
 		left := strings.Repeat(" ", leftW)
 		if ri := a.top + i; ri < len(a.results) {
 			left = padRaw(truncate(a.results[ri].text(), leftW), leftW)
 			if ri == a.sel {
 				left = "\x1b[7m" + left + "\x1b[0m"
 			}
 		}
 		right := ""
 		if i < len(prev) {
 			right = prev[i]
 		}
 		sb.WriteString(left)
 		sb.WriteString(" \x1b[2m│\x1b[0m ")
 		sb.WriteString(right)
 		sb.WriteString("\r\n")
 	}
 	fmt.Print(strings.TrimSuffix(sb.String(), "\r\n"))
 }
 
 // previewLines renders the selection's text centred on the matched line
 func (a *app) previewLines(w, h int) []string {
 	m, ok := a.cur()
 	if !ok || w < 4 {
 		return nil
 	}
 	if len(m.d.lines) == 0 {
 		return []string{"\x1b[2m(no cached text)\x1b[0m"}
 	}
 	start := 0
 	if m.line > 0 {
 		start = max(0, m.line-1-h/2)
 	}
 	var out []string
 	for i := start; i < len(m.d.lines) && len(out) < h; i++ {
 		row := truncate(m.d.lines[i], w-2)
 		if i+1 == m.line {
 			out = append(out, "\x1b[1m"+row+"\x1b[0m")
 		} else {
 			out = append(out, "\x1b[2m"+row+"\x1b[0m")
 		}
 	}
 	return out
 }
 
 func (a *app) withExternal(fn func()) {
 	a.leave()
 	fn()
 	a.resume()
 }
 
 func (a *app) open() {
 	m, ok := a.cur()
 	if !ok {
 		return
 	}
 	src := m.d.src
 	a.withExternal(func() {
 		if strings.HasSuffix(strings.ToLower(src), ".md") {
 			tmp, err := os.CreateTemp("", "wrd-*.html")
 			if err != nil {
 				return
 			}
 			defer func() { _ = os.Remove(tmp.Name()) }()
 			out, _ := exec.Command("lowdown", src).Output()
 			_, _ = tmp.Write(out)
 			_ = tmp.Close()
 			src = tmp.Name()
 		}
 		runTTY(exec.Command("cha", src))
 	})
 }
 
 func (a *app) openURL() {
 	if m, ok := a.cur(); ok {
 		u := url(m.d.rel)
 		a.withExternal(func() { runTTY(exec.Command("cha", u)) })
 	}
 }
 
 func (a *app) yank() {
 	m, ok := a.cur()
 	if !ok {
 		return
 	}
 	clip := url(m.d.rel)
 	var cmds []*exec.Cmd
 	if runtime.GOOS == "darwin" {
 		cmds = []*exec.Cmd{exec.Command("pbcopy")}
 	} else if os.Getenv("WAYLAND_DISPLAY") != "" {
 		cmds = []*exec.Cmd{exec.Command("wl-copy")}
 	} else {
 		cmds = []*exec.Cmd{exec.Command("xclip", "-selection", "clipboard")}
 	}
 	for _, cmd := range cmds {
 		cmd.Stdin = strings.NewReader(clip)
 		if cmd.Run() == nil {
 			return
 		}
 	}
 }
 
 func runTTY(cmd *exec.Cmd) {
 	cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
 	_ = cmd.Run()
 }
 
 // visLen counts visible runes, ignoring SGR escapes
 func visLen(s string) int {
 	n, esc := 0, false
 	for _, r := range s {
 		switch {
 		case esc:
 			esc = r != 'm'
 		case r == 0x1b:
 			esc = true
 		default:
 			n++
 		}
 	}
 	return n
 }
 
 func truncate(s string, w int) string {
 	rs := []rune(s)
 	if w <= 0 {
 		return ""
 	}
 	if len(rs) <= w {
 		return s
 	}
 	if w == 1 {
 		return string(rs[:1])
 	}
 	return string(rs[:w-1]) + "…"
 }
 
 func padRaw(s string, w int) string {
 	rs := []rune(s)
 	if len(rs) >= w {
 		return string(rs[:w])
 	}
 	return s + strings.Repeat(" ", w-len(rs))
 }
 
 func pad(s string, w int) string {
 	if v := visLen(s); v < w {
 		return s + strings.Repeat(" ", w-v)
 	}
 	return s
 }