refactor: internalize terminal logic

Co-authored-by: ccoVeille <[email protected]>

Author: Andrei-hub11

ansi_windows.go

@@ -2,40 +2,10 @@
 
 package godump
 
-import (
-	"os"
-	"syscall"
-	"unsafe"
-)
+import "github.com/goforj/godump/internal/windowsansi"
 
-// 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.
+// init activates ANSI support on Windows terminals by calling the Enable
+// function from the internal windowsansi package.
 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))
+	windowsansi.Enable()
 } 

godump.go

@@ -12,6 +12,8 @@ import (
 	"text/tabwriter"
 	"unicode/utf8"
 	"unsafe"
+
+	"github.com/goforj/godump/internal/terminal"
 )
 
 const (
@@ -619,6 +621,6 @@ func detectColor() bool {
 	if os.Getenv("FORCE_COLOR") != "" {
 		return true
 	}
-	
-	return isTerminal(os.Stdout)
+
+	return terminal.IsTerminal(os.Stdout)
 }

internal/terminal/terminal.go

@@ -0,0 +1,8 @@
+package terminal
+
+import "testing"
+
+// IsTestEnv is a variable that holds the testing.Testing function.
+// It's used to determine if the code is running in a test environment,
+// and it can be mocked in tests to control behavior.
+var IsTestEnv = testing.Testing 

terminal_unix.go renamed to internal/terminal/terminal_unix.go

@@ -1,19 +1,16 @@
 //go:build !windows
 
-package godump
+package terminal
 
 import (
 	"os"
-	"testing"
 )
 
-var isTestEnv = testing.Testing
-
-// isTerminal checks if the given file is a terminal.
+// IsTerminal checks if the given file is a terminal.
 // Uses ModeCharDevice on Unix-like systems.
 // In test environments, it returns true unless explicitly overridden by environment variables.
-func isTerminal(f *os.File) bool {
-	if isTestEnv() {
+func IsTerminal(f *os.File) bool {
+	if IsTestEnv() {
 		return true
 	}
 
@@ -22,4 +19,4 @@ func isTerminal(f *os.File) bool {
 		return false
 	}
 	return (fileInfo.Mode() & os.ModeCharDevice) != 0
-}
+} 

terminal_unix_test.go renamed to internal/terminal/terminal_unix_test.go

@@ -1,4 +1,4 @@
-package godump
+package terminal
 
 import (
 	"os"
@@ -8,18 +8,18 @@ import (
 )
 
 func TestIsTerminal_Unix(t *testing.T) {
-	// Mock isTestEnv to bypass the test environment check
-	originalIsTestEnv := isTestEnv
-	isTestEnv = func() bool { return false }
-	defer func() { isTestEnv = originalIsTestEnv }()
+	// Mock IsTestEnv to bypass the test environment check
+	originalIsTestEnv := IsTestEnv
+	IsTestEnv = func() bool { return false }
+	defer func() { IsTestEnv = originalIsTestEnv }()
 
 	t.Run("should return false for a regular file", func(t *testing.T) {
 		tmpFile, err := os.CreateTemp("", "test-is-terminal")
 		assert.NoError(t, err)
 		defer os.Remove(tmpFile.Name())
 		defer tmpFile.Close()
 
-		assert.False(t, isTerminal(tmpFile))
+		assert.False(t, IsTerminal(tmpFile))
 	})
 
 	t.Run("should return false when stat fails", func(t *testing.T) {
@@ -28,14 +28,14 @@ func TestIsTerminal_Unix(t *testing.T) {
 		tmpFile.Close()
 		os.Remove(tmpFile.Name())
 
-		assert.False(t, isTerminal(tmpFile))
+		assert.False(t, IsTerminal(tmpFile))
 	})
 
 	t.Run("should return true when in test environment", func(t *testing.T) {
-		isTestEnv = func() bool { return true }
+		IsTestEnv = func() bool { return true }
 		defer func() {
-			isTestEnv = originalIsTestEnv
+			IsTestEnv = originalIsTestEnv
 		}()
-		assert.True(t, isTerminal(os.Stdout))
+		assert.True(t, IsTerminal(os.Stdout))
 	})
 } 

terminal_windows.go renamed to internal/terminal/terminal_windows.go

@@ -1,20 +1,17 @@
 //go:build windows
 
-package godump
+package terminal
 
 import (
 	"os"
 	"syscall"
-	"testing"
 )
 
-var isTestEnv = testing.Testing
-
-// isTerminal checks if the given file is a terminal.
+// IsTerminal checks if the given file is a terminal.
 // Uses GetConsoleMode on Windows.
 // In test environments, it returns true unless explicitly overridden by environment variables.
-func isTerminal(f *os.File) bool {
-	if isTestEnv() {
+func IsTerminal(f *os.File) bool {
+	if IsTestEnv() {
 		return true
 	}
 
@@ -23,4 +20,4 @@ func isTerminal(f *os.File) bool {
 	// Fails for redirected/piped output
 	err := syscall.GetConsoleMode(syscall.Handle(f.Fd()), &mode)
 	return err == nil
-}
+} 

terminal_windows_test.go renamed to internal/terminal/terminal_windows_test.go

@@ -1,6 +1,6 @@
 //go:build windows
 
-package godump
+package terminal
 
 import (
 	"os"
@@ -10,10 +10,10 @@ import (
 )
 
 func TestIsTerminal_Windows(t *testing.T) {
-	// Mock isTestEnv to bypass the test environment check
-	originalIsTestEnv := isTestEnv
-	isTestEnv = func() bool { return false }
-	defer func() { isTestEnv = originalIsTestEnv }()
+	// Mock IsTestEnv to bypass the test environment check
+	originalIsTestEnv := IsTestEnv
+	IsTestEnv = func() bool { return false }
+	defer func() { IsTestEnv = originalIsTestEnv }()
 
 	t.Run("should return false for a regular file", func(t *testing.T) {
 		tmpFile, err := os.CreateTemp("", "test-is-terminal-windows")
@@ -22,13 +22,13 @@ func TestIsTerminal_Windows(t *testing.T) {
 		defer tmpFile.Close()
 
 		// On Windows, GetConsoleMode should fail for a regular file, so isTerminal returns false.
-		assert.False(t, isTerminal(tmpFile))
+		assert.False(t, IsTerminal(tmpFile))
 	})
 
 	t.Run("should return true when in test environment", func(t *testing.T) {
-		isTestEnv = func() bool { return true }
-		defer func() { isTestEnv = originalIsTestEnv }()
-		
-		assert.True(t, isTerminal(os.Stdout))
+		IsTestEnv = func() bool { return true }
+		defer func() { IsTestEnv = originalIsTestEnv }()
+
+		assert.True(t, IsTerminal(os.Stdout))
 	})
 } 

internal/windowsansi/winansi.go

@@ -0,0 +1,41 @@
+//go:build windows
+
+package windowsansi
+
+import (
+	"os"
+	"syscall"
+	"unsafe"
+)
+
+// Enable 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 Enable() {
+	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))
+}