feat: port to tablewriter 1.0.4

We got a Dependabot bump to this version. Previously we were on a
pre-1.0 version, but 1.0 came out this month.

There were some minor API breaks - renamed fields and slightly changed
concepts. The main difference that I can see, though, is that direct
handling of colours was removed.

In the `ci list` subcommand, we output a table containing the check runs
and statuses for a pull request or commit. As a bonus feature on a
terminal we'll colour those ("Passed" is green, etc). We also pass them
through a [`caser`] to make them into Title Case.

The removal of the colour support isn't too bad in itself. We already
had a function to map check statuses to colours. All we needed to do
there was to move this over to the type's `String()` method, using the
[`color`] library which we already use.

The problem comes when we then try to title case these strings. The
title caser has no understanding of terminal colour codes at all. So
here we make a wrapper [`transformer`] that strips the colour codes
before passing the plain text to the underlying `caser`, before
reassembling back to keep the colours.

This ended up being quite a bit of work due to the way that transformers
work - they can be called partially in a sort of streaming mode. But
it's all in here and working now. The wrapper has an extensive testsuite
to help build confidence that it works properly, since it's challenging
code to follow and the concepts involved are a bit difficult to
understand too.

Why is it OK to include colour codes in the string results? That's
because the `fatih/color` library auto-detects if the output is going to
a terminal or not before emitting the codes. In fact, we already did
this for the case of job names.

[`caser`]: https://pkg.go.dev/golang.org/x/text/cases#Title
[`color`]: https://pkg.go.dev/github.com/fatih/color
[`transformer`]: https://pkg.go.dev/golang.org/x/text/transform#Transformer

Author: iainlane

cmd/wait-for-github/ci_list.go

@@ -18,94 +18,107 @@ package main
 
 import (
 	"context"
+	"fmt"
 	"io"
 	"os"
 
+	"github.com/fatih/color"
+	"github.com/grafana/wait-for-github/internal/ansi"
 	"github.com/grafana/wait-for-github/internal/github"
-	"github.com/mattn/go-isatty"
 	"github.com/olekukonko/tablewriter"
+	"github.com/olekukonko/tablewriter/renderer"
+	"github.com/olekukonko/tablewriter/tw"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
 )
 
 type checkListConfig struct {
 	ciConfig
 	githubClient github.GetDetailedCIStatus
 }
 
-var caser = cases.Title(language.English)
-
-func statusColor(check github.CICheckStatus) tablewriter.Colors {
-	switch check.Outcome() {
-	case github.CIStatusPassed:
-		return tablewriter.Colors{tablewriter.FgGreenColor}
-	case github.CIStatusFailed:
-		return tablewriter.Colors{tablewriter.FgRedColor}
-	case github.CIStatusPending:
-		return tablewriter.Colors{tablewriter.FgYellowColor}
-	case github.CIStatusSkipped:
-		return tablewriter.Colors{tablewriter.FgHiBlackColor}
-	default:
-		return tablewriter.Colors{tablewriter.FgWhiteColor}
-	}
-}
+var caser = ansi.NewANSITransformer(cases.Title(language.English))
 
 // tableWriter is a wrapper around the tablewriter library, provided so that
 // tests can mock the table writing process
 type tableWriter interface {
-	SetHeader(headers []string)
-	Rich(row []string, colors []tablewriter.Colors)
-	Render()
+	Header(headers ...any)
+	Bulk(data any) error
+	Render() error
 }
 
+type realTableWriter = tablewriter.Table
+
+var _ tableWriter = (*realTableWriter)(nil)
+
 func newTableWriter(w io.Writer) (tableWriter, error) {
-	tw := tablewriter.NewWriter(w)
-	tw.SetAutoWrapText(false)
+	colorConfig := renderer.ColorizedConfig{
+		Header: renderer.Tint{
+			FG: renderer.Colors{color.FgBlack, color.Bold},
+		},
+		Border:    renderer.Tint{FG: renderer.Colors{color.FgWhite}},
+		Separator: renderer.Tint{FG: renderer.Colors{color.FgWhite}},
 
-	if err := tw.SetUnicodeHV(tablewriter.Double, tablewriter.Regular); err != nil {
-		return nil, err
+		Column: renderer.Tint{BG: renderer.Colors{color.Reset}},
 	}
 
-	return tw, nil
+	table := tablewriter.NewTable(w,
+		tablewriter.WithRenderer(renderer.NewColorized(
+			colorConfig,
+		)),
+		tablewriter.WithConfig(tablewriter.Config{
+			Row: tw.CellConfig{
+				Formatting: tw.CellFormatting{
+					AutoWrap: tw.WrapNone,
+				},
+			},
+		}),
+	)
+
+	return table, nil
 }
 
-func listChecks(ctx context.Context, cfg *checkListConfig, table tableWriter, useColors bool) error {
+func listChecks(ctx context.Context, cfg *checkListConfig, table tableWriter) error {
 	checks, err := cfg.githubClient.GetDetailedCIStatus(ctx, cfg.owner, cfg.repo, cfg.ref)
 	if err != nil {
 		return err
 	}
 
 	if len(checks) == 0 {
 		// For empty results, still use the table but with a single message row
-		table.SetHeader([]string{"Status"})
-		table.Rich([]string{"No CI checks found"}, nil)
-		table.Render()
+		table.Header([]string{"Status"})
+
+		if err := table.Bulk([]string{"No CI checks found"}); err != nil {
+			return fmt.Errorf("failed to write table: %w", err)
+		}
+
+		if err := table.Render(); err != nil {
+			return fmt.Errorf("failed to render table: %w", err)
+		}
 
 		return nil
 	}
 
-	table.SetHeader([]string{"Name", "Type", "Status"})
+	table.Header([]string{"Name", "Type", "Status"})
 
+	var data [][]string
 	for _, check := range checks {
-		var colors []tablewriter.Colors
-		if useColors {
-			colors = []tablewriter.Colors{
-				{},
-				{},
-				statusColor(check),
-			}
-		}
+		checkOutcomeString, _, _ := transform.String(caser, check.Outcome().String())
 
-		table.Rich([]string{
+		data = append(data, []string{
 			check.String(),
 			check.Type(),
-			caser.String(check.Outcome().String()),
-		}, colors)
+			checkOutcomeString,
+		})
 	}
 
-	table.Render()
-	return nil
+	if err := table.Bulk(data); err != nil {
+		return fmt.Errorf("failed to write table: %w", err)
+	}
+
+	return table.Render()
 }
 
 func ciListCommand(cfg *config) *cli.Command {
@@ -130,12 +143,10 @@ func ciListCommand(cfg *config) *cli.Command {
 				return err
 			}
 
-			useColor := isatty.IsTerminal(w.Fd()) && os.Getenv("NO_COLOR") == ""
-
 			return listChecks(c.Context, &checkListConfig{
 				ciConfig:     ciConf,
 				githubClient: githubClient,
-			}, table, useColor)
+			}, table)
 		},
 	}
 }