Switch to using bubbletea to redraw terminal status message

Author: nathanjcochran

internal/tiger/cmd/service.go

@@ -815,8 +815,8 @@ func waitForServiceReady(client *api.ClientWithResponses, projectID, serviceID s
 	defer ticker.Stop()
 
 	// Start the spinner
-	spinner := newSpinner(ctx, output, "Service status: %s", util.DerefStr(initialStatus))
-	defer spinner.stop()
+	spinner := NewSpinner(output, "Service status: %s", util.DerefStr(initialStatus))
+	defer spinner.Stop()
 
 	lastStatus := initialStatus
 	for {
@@ -826,12 +826,12 @@ func waitForServiceReady(client *api.ClientWithResponses, projectID, serviceID s
 		case <-ticker.C:
 			resp, err := client.GetProjectsProjectIdServicesServiceIdWithResponse(ctx, projectID, serviceID)
 			if err != nil {
-				spinner.update("Error checking service status: %v", err)
+				spinner.Update("Error checking service status: %v", err)
 				continue
 			}
 
 			if resp.StatusCode() != 200 || resp.JSON200 == nil {
-				spinner.update("Service not found or error checking status")
+				spinner.Update("Service not found or error checking status")
 				continue
 			}
 
@@ -841,13 +841,13 @@ func waitForServiceReady(client *api.ClientWithResponses, projectID, serviceID s
 
 			switch status {
 			case "READY":
-				spinner.stop()
+				spinner.Stop()
 				fmt.Fprintf(output, "🎉 Service is ready and running!\n")
 				return service.Status, nil
 			case "FAILED", "ERROR":
 				return service.Status, fmt.Errorf("service creation failed with status: %s", status)
 			default:
-				spinner.update("Service status: %s", status)
+				spinner.Update("Service status: %s", status)
 			}
 		}
 	}
@@ -1020,8 +1020,8 @@ func waitForServiceDeletion(client *api.ClientWithResponses, projectID string, s
 	statusOutput := cmd.ErrOrStderr()
 
 	// Start the spinner
-	spinner := newSpinner(ctx, statusOutput, "Waiting for service '%s' to be deleted", serviceID)
-	defer spinner.stop()
+	spinner := NewSpinner(statusOutput, "Waiting for service '%s' to be deleted", serviceID)
+	defer spinner.Stop()
 
 	for {
 		select {
@@ -1040,7 +1040,7 @@ func waitForServiceDeletion(client *api.ClientWithResponses, projectID string, s
 
 			if resp.StatusCode() == 404 {
 				// Service is deleted
-				spinner.stop()
+				spinner.Stop()
 				fmt.Fprintf(statusOutput, "✅ Service '%s' has been successfully deleted.\n", serviceID)
 				return nil
 			}

internal/tiger/cmd/spinner.go

@@ -1,136 +1,126 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"os"
-	"strings"
-	"sync"
 	"time"
 
+	tea "github.com/charmbracelet/bubbletea"
 	"golang.org/x/term"
 )
 
 // spinnerFrames defines the animation frames for the spinner
 var spinnerFrames = []string{"⢎ ", "⠎⠁", "⠊⠑", "⠈⠱", " ⡱", "⢀⡰", "⢄⡠", "⢆⡀"}
 
-// spinner wraps output to show a nice spinner that updates in place
-type spinner struct {
-	ctx         context.Context
-	cancel      context.CancelFunc
-	done        chan struct{}
-	lock        sync.Mutex
-	output      io.Writer
-	tty         bool
-	message     string
-	frame       int
-	lastLineLen int
+type Spinner struct {
+	// Populated when output is a TTY
+	program *tea.Program
+
+	// Populated when output is not a TTY
+	output io.Writer
+	model  *spinnerModel
 }
 
-func newSpinner(ctx context.Context, output io.Writer, message string, args ...any) *spinner {
-	ctx, cancel := context.WithCancel(ctx)
-	s := &spinner{
-		ctx:     ctx,
-		cancel:  cancel,
-		output:  output,
+func NewSpinner(output io.Writer, message string, args ...any) *Spinner {
+	model := spinnerModel{
 		message: fmt.Sprintf(message, args...),
-		done:    make(chan struct{}),
 	}
 
-	// Check if output is a TTY
-	if f, ok := output.(*os.File); ok {
-		s.tty = term.IsTerminal(int(f.Fd()))
+	// If output is not a TTY, print each message on a new line
+	if !isTerminal(output) {
+		s := &Spinner{
+			output: output,
+			model:  &model,
+		}
+		s.println()
+		return s
 	}
 
-	// Start the spinner animation in a goroutine
-	go s.run()
+	// If output is a TTY, use bubbletea to dynamically update the message
+	program := tea.NewProgram(
+		model,
+		tea.WithOutput(output),
+	)
 
-	return s
-}
+	// Start the program in a goroutine
+	go func() {
+		if _, err := program.Run(); err != nil {
+			fmt.Fprintf(output, "Error displaying output: %s\n", err)
+		}
+	}()
 
-func (s *spinner) run() {
-	defer close(s.done)
+	return &Spinner{
+		program: program,
+	}
+}
 
-	// Initial render
-	s.render(true)
+func (s *Spinner) Update(message string, args ...any) {
+	message = fmt.Sprintf(message, args...)
+	if s.program != nil {
+		s.program.Send(updateMsg(message))
+	} else if message != s.model.message {
+		s.model.message = message
+		s.model.incFrame()
+		s.println()
+	}
+}
 
-	// If not outputting to a terminal, do not constantly re-render the spinner
-	if !s.tty {
+func (s *Spinner) Stop() {
+	if s.program == nil {
 		return
 	}
 
-	// Re-render the spinner every 100ms
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-s.ctx.Done():
-			// Clear the line when finished
-			s.lock.Lock()
-			s.clearLine()
-			s.lock.Unlock()
-			return
-		case <-ticker.C:
-			s.render(true)
-		}
-	}
+	s.program.Quit()
+	s.program.Wait()
 }
 
-func (s *spinner) render(incFrame bool) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
+func (s *Spinner) println() {
+	fmt.Fprintln(s.output, s.model.View())
+}
 
-	// Clear the previous line if outputting to a terminal
-	if s.tty {
-		s.clearLine()
+func isTerminal(w io.Writer) bool {
+	if f, ok := w.(*os.File); ok {
+		return term.IsTerminal(int(f.Fd()))
 	}
+	return false
+}
 
-	// Build the spinner line
-	spinnerFrame := spinnerFrames[s.frame]
-	if incFrame {
-		s.frame = (s.frame + 1) % len(spinnerFrames)
-	}
+// Message types for the bubbletea model
+type tickMsg struct{}
+type updateMsg string
 
-	line := fmt.Sprintf("%s %s", spinnerFrame, s.message)
-	s.lastLineLen = len(line)
+// spinnerModel is the bubbletea model for the spinner
+type spinnerModel struct {
+	message string
+	frame   int
+}
 
-	if s.tty {
-		// If outputting to a terminal, write without newline so it stays on the same line
-		fmt.Fprint(s.output, line)
-	} else {
-		// If not outputting to a terminal, write with a newline
-		fmt.Fprintln(s.output, line)
-	}
+func (m spinnerModel) Init() tea.Cmd {
+	return m.tick()
 }
 
-func (s *spinner) clearLine() {
-	if s.lastLineLen > 0 {
-		fmt.Fprint(s.output, "\r")
-		fmt.Fprint(s.output, strings.Repeat(" ", s.lastLineLen))
-		fmt.Fprint(s.output, "\r")
+func (m spinnerModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tickMsg:
+		m.incFrame()
+		return m, m.tick()
+	case updateMsg:
+		m.message = string(msg)
 	}
+	return m, nil
 }
 
-func (s *spinner) update(message string, args ...any) {
-	s.lock.Lock()
-	newMessage := fmt.Sprintf(message, args...)
-	changed := s.message != newMessage
-	s.message = newMessage
-	s.lock.Unlock()
-
-	// Immediately render the updated message, if it changed. Only increment
-	// the spinner frame if not outputting to a terminal (if outputting to a
-	// terminal, the spinner frame updates on a schedule via a time.Ticker).
-	if changed {
-		s.render(!s.tty)
-	}
+func (m spinnerModel) View() string {
+	return fmt.Sprintf("%s %s", spinnerFrames[m.frame], m.message)
 }
 
-func (s *spinner) stop() {
-	// Cancel the context to stop the spinner
-	s.cancel()
+func (m *spinnerModel) incFrame() {
+	m.frame = (m.frame + 1) % len(spinnerFrames)
+}
 
-	// Wait for spinner goroutine to finish rendering
-	<-s.done
+func (m *spinnerModel) tick() tea.Cmd {
+	return tea.Tick(100*time.Millisecond, func(time.Time) tea.Msg {
+		return tickMsg{}
+	})
 }