[cli] Abstract out terminal interactions

pkg/backend/display/diff_test.go

@@ -1,3 +1,4 @@
+//nolint:goconst
 package display
 
 import (

pkg/backend/display/internal/terminal/info.go

@@ -0,0 +1,79 @@
+package terminal
+
+import (
+	"fmt"
+	"io"
+
+	gotty "github.com/ijc/Gotty"
+)
+
+type Info interface {
+	Parse(attr string, params ...interface{}) (string, error)
+
+	ClearLine(out io.Writer)
+	CursorUp(out io.Writer, count int)
+	CursorDown(out io.Writer, count int)
+}
+
+/* Satisfied by gotty.TermInfo as well as noTermInfo from below */
+type termInfo interface {
+	Parse(attr string, params ...interface{}) (string, error)
+}
+
+type noTermInfo int // canary used when no terminfo.
+
+func (ti noTermInfo) Parse(attr string, params ...interface{}) (string, error) {
+	return "", fmt.Errorf("noTermInfo")
+}
+
+type info struct {
+	termInfo
+}
+
+var _ = Info(info{})
+
+func OpenInfo(terminal string) Info {
+	if i, err := gotty.OpenTermInfo(terminal); err == nil {
+		return info{i}
+	}
+	return info{noTermInfo(0)}
+}
+
+func (i info) ClearLine(out io.Writer) {
+	// el2 (clear whole line) is not exposed by terminfo.
+
+	// First clear line from beginning to cursor
+	if attr, err := i.Parse("el1"); err == nil {
+		fmt.Fprintf(out, "%s", attr)
+	} else {
+		fmt.Fprintf(out, "\x1b[1K")
+	}
+	// Then clear line from cursor to end
+	if attr, err := i.Parse("el"); err == nil {
+		fmt.Fprintf(out, "%s", attr)
+	} else {
+		fmt.Fprintf(out, "\x1b[K")
+	}
+}
+
+func (i info) CursorUp(out io.Writer, count int) {
+	if count == 0 { // Should never be the case, but be tolerant
+		return
+	}
+	if attr, err := i.Parse("cuu", count); err == nil {
+		fmt.Fprintf(out, "%s", attr)
+	} else {
+		fmt.Fprintf(out, "\x1b[%dA", count)
+	}
+}
+
+func (i info) CursorDown(out io.Writer, count int) {
+	if count == 0 { // Should never be the case, but be tolerant
+		return
+	}
+	if attr, err := i.Parse("cud", count); err == nil {
+		fmt.Fprintf(out, "%s", attr)
+	} else {
+		fmt.Fprintf(out, "\x1b[%dB", count)
+	}
+}

pkg/backend/display/internal/terminal/mock.go

@@ -0,0 +1,80 @@
+package terminal
+
+import (
+	"io"
+	"sync"
+)
+
+type MockTerminal struct {
+	m sync.Mutex
+
+	width, height int
+	raw           bool
+	info          Info
+
+	keys chan string
+
+	dest io.Writer
+}
+
+func NewMockTerminal(dest io.Writer, width, height int, raw bool) *MockTerminal {
+	return &MockTerminal{
+		width:  width,
+		height: height,
+		raw:    raw,
+		info:   info{noTermInfo(0)},
+		keys:   make(chan string),
+		dest:   dest,
+	}
+}
+
+func (t *MockTerminal) IsRaw() bool {
+	return t.raw
+}
+
+func (t *MockTerminal) Close() error {
+	close(t.keys)
+	return nil
+}
+
+func (t *MockTerminal) Size() (width, height int, err error) {
+	t.m.Lock()
+	defer t.m.Unlock()
+
+	return t.width, t.height, nil
+}
+
+func (t *MockTerminal) Write(b []byte) (int, error) {
+	return t.dest.Write(b)
+}
+
+func (t *MockTerminal) ClearLine() {
+	t.info.ClearLine(t)
+}
+
+func (t *MockTerminal) CursorUp(count int) {
+	t.info.CursorUp(t, count)
+}
+
+func (t *MockTerminal) CursorDown(count int) {
+	t.info.CursorDown(t, count)
+}
+
+func (t *MockTerminal) ReadKey() (string, error) {
+	k, ok := <-t.keys
+	if !ok {
+		return "", io.EOF
+	}
+	return k, nil
+}
+
+func (t *MockTerminal) SetSize(width, height int) {
+	t.m.Lock()
+	defer t.m.Unlock()
+
+	t.width, t.height = width, height
+}
+
+func (t *MockTerminal) SendKey(key string) {
+	t.keys <- key
+}

pkg/backend/display/internal/terminal/term.go

@@ -0,0 +1,202 @@
+package terminal
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/muesli/cancelreader"
+	"golang.org/x/term"
+)
+
+type Terminal interface {
+	io.WriteCloser
+
+	IsRaw() bool
+	Size() (width, height int, err error)
+
+	ClearLine()
+	CursorUp(count int)
+	CursorDown(count int)
+
+	ReadKey() (string, error)
+}
+
+var ErrNotATerminal = errors.New("not a terminal")
+
+type terminal struct {
+	fd   int
+	info Info
+	raw  bool
+	save *term.State
+
+	out io.Writer
+	in  cancelreader.CancelReader
+}
+
+func Open(in io.Reader, out io.Writer, raw bool) (Terminal, error) {
+	type fileLike interface {
+		Fd() uintptr
+	}
+
+	outFile, ok := out.(fileLike)
+	if !ok {
+		return nil, ErrNotATerminal
+	}
+	outFd := int(outFile.Fd())
+
+	width, height, err := term.GetSize(outFd)
+	if err != nil {
+		return nil, fmt.Errorf("getting dimensions: %w", err)
+	}
+	if width == 0 || height == 0 {
+		return nil, fmt.Errorf("unusable dimensions (%v x %v)", width, height)
+	}
+
+	termType := os.Getenv("TERM")
+	if termType == "" {
+		termType = "vt102"
+	}
+	info := OpenInfo(termType)
+
+	var save *term.State
+	var inFile cancelreader.CancelReader
+	if raw {
+		if save, err = term.MakeRaw(outFd); err != nil {
+			return nil, fmt.Errorf("enabling raw mode: %w", err)
+		}
+		if inFile, err = cancelreader.NewReader(in); err != nil {
+			return nil, ErrNotATerminal
+		}
+	}
+
+	return &terminal{
+		fd:   outFd,
+		info: info,
+		raw:  raw,
+		save: save,
+		out:  out,
+		in:   inFile,
+	}, nil
+}
+
+func (t *terminal) IsRaw() bool {
+	return t.raw
+}
+
+func (t *terminal) Close() error {
+	t.in.Cancel()
+	if t.save != nil {
+		return term.Restore(t.fd, t.save)
+	}
+	return nil
+}
+
+func (t *terminal) Size() (width, height int, err error) {
+	return term.GetSize(t.fd)
+}
+
+func (t *terminal) Write(b []byte) (int, error) {
+	if !t.raw {
+		return t.out.Write(b)
+	}
+
+	written := 0
+	for {
+		newline := bytes.IndexByte(b, '\n')
+		if newline == -1 {
+			w, err := t.out.Write(b)
+			written += w
+			return written, err
+		}
+
+		w, err := t.out.Write(b[:newline])
+		written += w
+		if err != nil {
+			return written, err
+		}
+
+		if _, err = t.out.Write([]byte{'\r', '\n'}); err != nil {
+			return written, err
+		}
+		written++
+
+		b = b[newline+1:]
+	}
+}
+
+func (t *terminal) ClearLine() {
+	t.info.ClearLine(t.out)
+}
+
+func (t *terminal) CursorUp(count int) {
+	t.info.CursorUp(t.out, count)
+}
+
+func (t *terminal) CursorDown(count int) {
+	t.info.CursorDown(t.out, count)
+}
+
+func (t *terminal) ReadKey() (string, error) {
+	if t.in == nil {
+		return "", io.EOF
+	}
+
+	type stateFunc func(b byte) (stateFunc, string)
+
+	var stateIntermediate stateFunc
+	stateIntermediate = func(b byte) (stateFunc, string) {
+		if b >= 0x20 && b < 0x30 {
+			return stateIntermediate, ""
+		}
+		switch b {
+		case 'A':
+			return nil, "up"
+		case 'B':
+			return nil, "down"
+		default:
+			return nil, "<control>"
+		}
+	}
+	var stateParameter stateFunc
+	stateParameter = func(b byte) (stateFunc, string) {
+		if b >= 0x30 && b < 0x40 {
+			return stateParameter, ""
+		}
+		return stateIntermediate(b)
+	}
+	stateBracket := func(b byte) (stateFunc, string) {
+		if b == '[' {
+			return stateParameter, ""
+		}
+		return nil, "<control>"
+	}
+	stateEscape := func(b byte) (stateFunc, string) {
+		if b == 0x1b {
+			return stateBracket, ""
+		}
+		if b == 3 {
+			return nil, "ctrl+c"
+		}
+		return nil, string([]byte{b})
+	}
+
+	state := stateEscape
+	for {
+		var b [1]byte
+		if _, err := t.in.Read(b[:]); err != nil {
+			if errors.Is(err, cancelreader.ErrCanceled) {
+				err = io.EOF
+			}
+			return "", err
+		}
+
+		next, key := state(b[0])
+		if next == nil {
+			return key, nil
+		}
+		state = next
+	}
+}