feat: Adds ANSI color support for Windows terminals and prevents color output

when stdout is not a TTY

Author: Andrei-hub11

ansi_windows.go

@@ -0,0 +1,41 @@
+//go:build windows
+
+package godump
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+// init activates ANSI support on Windows terminals by setting the
+// ENABLE_VIRTUAL_TERMINAL_PROCESSING flag.
+// It fails silently if the output is not a console.
+func init() {
+	const enableVirtualTerminalProcessing = 0x0004
+
+	// Load kernel32.dll and the necessary procedures dynamically.
+	// This avoids a hard dependency and allows the program to run on non-Windows
+	// systems, although this file is guarded by a build tag.
+	kernel32 := syscall.NewLazyDLL("kernel32.dll")
+	procGetConsoleMode := kernel32.NewProc("GetConsoleMode")
+	procSetConsoleMode := kernel32.NewProc("SetConsoleMode")
+
+	// Get the handle for standard output.
+	handle := syscall.Handle(os.Stdout.Fd())
+	var mode uint32
+
+	// GetConsoleMode fails if not in a real console.
+	ret, _, _ := procGetConsoleMode.Call(uintptr(handle), uintptr(unsafe.Pointer(&mode)))
+	if ret == 0 {
+		return
+	}
+
+	// Add the virtual terminal processing flag to the current mode.
+	newMode := mode | enableVirtualTerminalProcessing
+
+	// Try to set the new console mode.
+	// If this call fails, we also silently continue. The result will be
+	// that colors are not rendered, which is an acceptable fallback.
+	procSetConsoleMode.Call(uintptr(handle), uintptr(newMode))
+} 

godump.go

@@ -9,6 +9,7 @@ import (
 	"reflect"
 	"runtime"
 	"strings"
+	"syscall"
 	"text/tabwriter"
 	"unicode/utf8"
 	"unsafe"
@@ -619,5 +620,25 @@ func detectColor() bool {
 	if os.Getenv("FORCE_COLOR") != "" {
 		return true
 	}
-	return true
-}
+	
+	return isTerminal(os.Stdout)
+}
+
+// isTerminal checks if the given file is a terminal.
+// Uses GetConsoleMode on Windows, ModeCharDevice on Unix.
+func isTerminal(f *os.File) bool {
+    if runtime.GOOS == "windows" {
+        var mode uint32
+        // GetConsoleMode succeeds only for console handles
+        // Fails for redirected/piped output
+        err := syscall.GetConsoleMode(syscall.Handle(f.Fd()), &mode)
+        return err == nil
+    }
+    
+    // Unix: ModeCharDevice works reliably
+    fileInfo, err := f.Stat()
+    if err != nil {
+        return false
+    }
+    return (fileInfo.Mode() & os.ModeCharDevice) != 0
+}

godump_integration_test.go

@@ -0,0 +1,89 @@
+package godump
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// TestAnsiInNonTty verifies that no ANSI codes are produced when output is redirected.
+func TestAnsiInNonTty(t *testing.T) {
+	// ANSI escape character. We expect this to be ABSENT from the output.
+	const escape = "\x1b"
+
+	// The source code for the program we're going to run.
+	const sourceCode = `
+package main
+import "github.com/goforj/godump"
+func main() {
+    s := struct{ Name string }{"test"}
+    godump.Dump(s)
+}
+`
+
+	// Create a temporary directory to avoid package main collision.
+	tempDir := t.TempDir()
+	tempFile, err := os.CreateTemp(tempDir, "test_*.go")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+
+	if _, err := tempFile.WriteString(sourceCode); err != nil {
+		t.Fatalf("failed to write temp file: %v", err)
+	}
+	tempFile.Close()
+
+	// Run the program using `go run`. By capturing the output, we ensure
+	// that the program's stdout is not a TTY.
+	cmd := exec.Command("go", "run", tempFile.Name())
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("failed to run test program: %v\nOutput:\n%s", err, string(output))
+	}
+
+	if strings.Contains(string(output), escape) {
+		t.Errorf("expected output to NOT contain ANSI escape codes when not in a TTY, but it did. Output:\n%s", string(output))
+	}
+}
+
+// TestAnsiInTty verifies that ANSI codes are produced when FORCE_COLOR is set.
+func TestAnsiInTty(t *testing.T) {
+	// ANSI escape character. We expect this to be PRESENT in the output.
+	const escape = "\x1b"
+
+	// The source code for the program we're going to run.
+	const sourceCode = `
+package main
+import "github.com/goforj/godump"
+func main() {
+    s := struct{ Name string }{"test"}
+    godump.Dump(s)
+}
+`
+	// Create a temporary directory to avoid package main collision.
+	tempDir := t.TempDir()
+	tempFile, err := os.CreateTemp(tempDir, "test_*.go")
+	if err != nil {
+		t.Fatalf("failed to create temp file: %v", err)
+	}
+
+	if _, err := tempFile.WriteString(sourceCode); err != nil {
+		t.Fatalf("failed to write temp file: %v", err)
+	}
+	tempFile.Close()
+
+	// Run the program using `go run`. By capturing the output, we ensure
+	// that the program's stdout is not a TTY.
+	cmd := exec.Command("go", "run", tempFile.Name())
+
+	cmd.Env = append(os.Environ(), "FORCE_COLOR=1")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("failed to run test program: %v\nOutput:\n%s", err, string(output))
+	}
+
+	if !strings.Contains(string(output), escape) {
+		t.Errorf("expected output to contain ANSI escape codes when FORCE_COLOR is set, but it didn't. Output:\n%s", string(output))
+	}
+}