Replace tabwriter with custom implementation for ANSI color support

The standard library tabwriter doesn't account for ANSI escape codes
when calculating column widths, causing misaligned output with colored
text. This replaces it with a custom implementation that uses runeLen()
to properly calculate display widths.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: wpjunior

render.go

@@ -6,14 +6,11 @@ package tablecli
 
 import (
 	"bytes"
-	"fmt"
-	"io"
 	"os"
 	"reflect"
 	"regexp"
 	"sort"
 	"strings"
-	"text/tabwriter"
 	"unicode"
 	"unicode/utf8"
 
@@ -221,60 +218,88 @@ func (t *Table) resizeLargestColumn(ttyWidth int) []int {
 	return t.columnsSize()
 }
 
-const (
-	tabwriterMinWidth = 6
-	tabwriterWidth    = 4
-	tabwriterPadding  = 3
-	tabwriterPadChar  = ' '
-)
-
-// getNewTabWriter returns a tabwriter that translates tabbed columns in input into properly aligned text.
-func getNewTabWriter(output io.Writer) *tabwriter.Writer {
-	return tabwriter.NewWriter(output, tabwriterMinWidth, tabwriterWidth, tabwriterPadding, tabwriterPadChar, 0)
-}
-
 var tableWriterReplacer = strings.NewReplacer(
 	"\f", " ",
 	"\n", " ",
 	"\r", " ",
 )
 
-func (t *Table) renderUsingTabWriter() string {
-	buf := bytes.NewBuffer(nil)
-	w := getNewTabWriter(buf)
+func (t *Table) renderUsingTabWriterLike() string {
 	padding := strings.Repeat(" ", t.TableWriterPadding)
 
-	if len(t.Headers) > 0 {
-		capitalizedHeaders := []string{}
-		for _, header := range t.Headers {
-			capitalizedHeaders = append(capitalizedHeaders, strings.ToUpper(header))
+	// Process rows and calculate column widths
+	processedRows := make([][]string, len(t.rows))
+	for i, row := range t.rows {
+		processedRows[i] = make([]string, len(row))
+		for j, col := range row {
+			if idx := strings.IndexAny(col, "\f\n\r"); idx >= 0 {
+				if TableConfig.TabWriterTruncate || t.TableWriterTruncate {
+					col = col[:idx] + " ..."
+				} else {
+					col = tableWriterReplacer.Replace(col)
+				}
+			}
+			processedRows[i][j] = col
 		}
-		fmt.Fprintln(w, padding+strings.Join(capitalizedHeaders, "\t"))
 	}
 
-	for _, row := range t.rows {
-		newRow := make([]string, len(row))
-		for i, column := range row {
-			breakchar := strings.IndexAny(column, "\f\n\r")
-			if breakchar >= 0 {
-				if TableConfig.TabWriterTruncate || t.TableWriterTruncate {
-					column = column[:breakchar] + " ..."
-				} else {
-					column = tableWriterReplacer.Replace(column)
+	// Calculate column widths
+	var numCols int
+	if len(t.Headers) > 0 {
+		numCols = len(t.Headers)
+	} else if len(processedRows) > 0 {
+		numCols = len(processedRows[0])
+	}
+	widths := make([]int, numCols)
+	for i, h := range t.Headers {
+		if w := runeLen(h); w > widths[i] {
+			widths[i] = w
+		}
+	}
+	for _, row := range processedRows {
+		for i, col := range row {
+			if i < numCols {
+				if w := runeLen(col); w > widths[i] {
+					widths[i] = w
 				}
 			}
+		}
+	}
 
-			newRow[i] = column
+	// Build output
+	var buf strings.Builder
+	if len(t.Headers) > 0 {
+		buf.WriteString(padding)
+		for i, h := range t.Headers {
+			if i > 0 {
+				buf.WriteString("   ")
+			}
+			buf.WriteString(strings.ToUpper(h))
+			if i < numCols-1 {
+				buf.WriteString(strings.Repeat(" ", widths[i]-runeLen(h)))
+			}
+		}
+		buf.WriteString("\n")
+	}
+	for _, row := range processedRows {
+		buf.WriteString(padding)
+		for i, col := range row {
+			if i > 0 {
+				buf.WriteString("   ")
+			}
+			buf.WriteString(col)
+			if i < numCols-1 {
+				buf.WriteString(strings.Repeat(" ", widths[i]-runeLen(col)))
+			}
 		}
-		fmt.Fprintln(w, padding+strings.Join(newRow, "\t"))
+		buf.WriteString("\n")
 	}
-	w.Flush()
 	return buf.String()
 }
 
 func (t *Table) String() string {
 	if TableConfig.UseTabWriter {
-		return t.renderUsingTabWriter()
+		return t.renderUsingTabWriterLike()
 	}
 	if t.Headers == nil && len(t.rows) < 1 {
 		return ""

render_test.go

@@ -599,6 +599,42 @@ Mixed            a b c d
 	assert.Equal(t, expected, table.String())
 }
 
+func TestStringTabWriterWithANSIColors(t *testing.T) {
+	TableConfig.UseTabWriter = true
+	defer func() {
+		TableConfig.UseTabWriter = false
+	}()
+	table := NewTable()
+	table.Headers = Row{"ID", "Status", "Name"}
+	// ANSI color codes: \033[33;1;1m = yellow, \033[0m = reset
+	yellow := func(s string) string { return "\033[33;1;1m" + s + "\033[0m" }
+	red := func(s string) string { return "\033[31;1;1m" + s + "\033[0m" }
+	table.AddRow(Row{"abc123", "ok", "app1"})
+	table.AddRow(Row{yellow("def456"), yellow("running"), yellow("…")})
+	table.AddRow(Row{red("ghi789"), red("error"), red("app3")})
+	output := table.String()
+
+	// Verify alignment is correct (columns should align despite ANSI codes)
+	lines := strings.Split(output, "\n")
+	assert.Len(t, lines, 5) // header + 3 rows + trailing newline
+
+	// Check that ANSI codes are preserved in output
+	assert.Contains(t, output, "\033[33;1;1m")
+	assert.Contains(t, output, "\033[31;1;1m")
+	assert.Contains(t, output, "\033[0m")
+
+	// Verify the colored content is present
+	assert.Contains(t, output, "def456")
+	assert.Contains(t, output, "running")
+	assert.Contains(t, output, "error")
+	assert.Contains(t, output, "…")
+
+	assert.Equal(t, 23, runeLen(lines[1])) // First row
+	assert.Equal(t, 20, runeLen(lines[2])) // Second row
+	assert.Equal(t, 23, runeLen(lines[3])) // Third row
+	assert.Equal(t, 0, runeLen(lines[4]))  // Trailing newline
+}
+
 func BenchmarkString(b *testing.B) {
 	b.StopTimer()
 	table := NewTable()