watch: properly reset terminal after idle timeout

Previous the terminal would not be reset because the defer was in the
redo handler goroutine. This goroutine accepts a context, but because it
blocks on reading from stdin, it does not exit when the context is
cancelled.

To fix the problem, the defer is moved into the main goroutine.

internal/filewatcher/term_unix.go

@@ -12,6 +12,22 @@ import (
 	"gotest.tools/gotestsum/log"
 )
 
+type redoHandler struct {
+	prevPath string
+	ch       chan string
+	reset    func()
+}
+
+func newRedoHandler() *redoHandler {
+	fd := int(os.Stdin.Fd())
+	reset, err := enableNonBlockingRead(fd)
+	if err != nil {
+		log.Warnf("failed to put terminal (fd %d) into raw mode: %v", fd, err)
+		return nil
+	}
+	return &redoHandler{ch: make(chan string), reset: reset}
+}
+
 func enableNonBlockingRead(fd int) (func(), error) {
 	term, err := unix.IoctlGetTermios(fd, tcGet)
 	if err != nil {
@@ -35,15 +51,10 @@ func enableNonBlockingRead(fd int) (func(), error) {
 	return reset, nil
 }
 
-func (r *redoHandler) run(ctx context.Context) {
-	fd := int(os.Stdin.Fd())
-	reset, err := enableNonBlockingRead(fd)
-	if err != nil {
-		log.Debugf("failed to put terminal (fd %d) into raw mode: %v", fd, err)
+func (r *redoHandler) Run(ctx context.Context) {
+	if r == nil {
 		return
 	}
-	defer reset()
-
 	in := bufio.NewReader(os.Stdin)
 	for {
 		if ctx.Err() != nil {
@@ -65,3 +76,23 @@ func (r *redoHandler) run(ctx context.Context) {
 		}
 	}
 }
+
+func (r *redoHandler) Ch() <-chan string {
+	if r == nil {
+		return nil
+	}
+	return r.ch
+}
+
+func (r *redoHandler) Reset() {
+	if r != nil {
+		r.reset()
+	}
+}
+
+func (r *redoHandler) Save(path string) {
+	if r == nil {
+		return
+	}
+	r.prevPath = path
+}

internal/filewatcher/term_windows.go

@@ -2,6 +2,18 @@ package filewatcher
 
 import "context"
 
-func (r *redoHandler) run(_ context.Context) {
-	return
+type redoHandler struct{}
+
+func newRedoHandler() *redoHandler {
+	return nil
+}
+
+func (r *redoHandler) Run(_ context.Context) {}
+
+func (r *redoHandler) Ch() <-chan string {
+	return nil
 }
+
+func (r *redoHandler) Reset() {}
+
+func (r *redoHandler) Save(_ string) {}

internal/filewatcher/watch.go

@@ -33,18 +33,20 @@ func Watch(dirs []string, run func(pkg string) error) error {
 		}
 	}
 
-	timer := time.NewTimer(time.Hour)
+	timer := time.NewTimer(maxIdleTime)
 	defer timer.Stop()
 
-	redo := &redoHandler{ch: make(chan string)}
-	go redo.run(ctx)
+	redo := newRedoHandler()
+	defer redo.Reset()
+	go redo.Run(ctx)
+
 	h := &handler{last: time.Now(), fn: run}
 	for {
 		select {
 		case <-timer.C:
 			return fmt.Errorf("exceeded idle timeout while watching files")
 
-		case path := <-redo.ch:
+		case path := <-redo.Ch():
 			resetTimer(timer)
 			if err := h.runTests(path); err != nil {
 				return fmt.Errorf("failed to rerun tests for %v: %v", path, err)
@@ -61,19 +63,21 @@ func Watch(dirs []string, run func(pkg string) error) error {
 			if err := h.handleEvent(event); err != nil {
 				return fmt.Errorf("failed to run tests for %v: %v", event.Name, err)
 			}
-			redo.prevPath = event.Name
+			redo.Save(event.Name)
 
 		case err := <-watcher.Errors:
 			return fmt.Errorf("failed while watching files: %v", err)
 		}
 	}
 }
 
+const maxIdleTime = time.Hour
+
 func resetTimer(timer *time.Timer) {
 	if !timer.Stop() {
 		<-timer.C
 	}
-	timer.Reset(time.Hour)
+	timer.Reset(maxIdleTime)
 }
 
 func findAllDirs(dirs []string, maxDepth int) []string {
@@ -215,8 +219,3 @@ func (h *handler) runTests(path string) error {
 	h.last = time.Now()
 	return nil
 }
-
-type redoHandler struct {
-	prevPath string
-	ch       chan string
-}