refactor: unify windowsansi into ansi

Author: Andrei-hub11

ansi_windows.go

@@ -2,10 +2,18 @@
 
 package godump
 
-import "github.com/goforj/godump/internal/windowsansi"
+import (
+	"log"
+
+	"github.com/goforj/godump/internal/ansi"
+)
 
 // init activates ANSI support on Windows terminals by calling the Enable
-// function from the internal windowsansi package.
+// function from the internal ansi package.
+// If enabling ANSI fails (e.g., not running in a real console), it logs
+// the error but continues execution, as colors are optional.
 func init() {
-	windowsansi.Enable()
-} 
+	if err := ansi.Enable(); err != nil {
+		log.Printf("Warning: Failed to enable ANSI support: %v\n", err)
+	}
+}

go.mod

@@ -4,11 +4,11 @@ go 1.18
 
 require github.com/stretchr/testify v1.10.0
 
-require golang.org/x/sys v0.34.0 // indirect
+require golang.org/x/sys v0.30.0 // indirect
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	golang.org/x/term v0.33.0
+	golang.org/x/term v0.29.0
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -4,10 +4,10 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/sys v0.34.0 h1:H5Y5sJ2L2JRdyv7ROF1he/lPdvFsd0mJHFw2ThKHxLA=
-golang.org/x/sys v0.34.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.33.0 h1:NuFncQrRcaRvVmgRkvM3j/F00gWIAlcmlB8ACEKmGIg=
-golang.org/x/term v0.33.0/go.mod h1:s18+ql9tYWp1IfpV9DmCtQDDSRBUjKaw9M1eAv5UeF0=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

internal/windowsansi/winansi.go renamed to internal/ansi/ansi_windows.go

@@ -1,18 +1,22 @@
 //go:build windows
 
-package windowsansi
+package ansi
 
 import (
 	"os"
 	"syscall"
 	"unsafe"
 )
 
+const (
+	SYS_CALL_FAILURE                   = 0
+	enableVirtualTerminalProcessing     = 0x0004
+)
+
 // 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
+// Returns an error if the output is not a console or if setting the mode fails.
+func Enable() error {
 
 	// Load kernel32.dll and the necessary procedures dynamically.
 	// This avoids a hard dependency and allows the program to run on non-Windows
@@ -26,16 +30,19 @@ func Enable() {
 	var mode uint32
 
 	// GetConsoleMode fails if not in a real console.
-	ret, _, _ := procGetConsoleMode.Call(uintptr(handle), uintptr(unsafe.Pointer(&mode)))
-	if ret == 0 {
-		return
+	ret, _, err := procGetConsoleMode.Call(uintptr(handle), uintptr(unsafe.Pointer(&mode)))
+	if ret == SYS_CALL_FAILURE {
+		return err
 	}
 
 	// 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))
+	ret, _, err = procSetConsoleMode.Call(uintptr(handle), uintptr(newMode))
+	if ret == SYS_CALL_FAILURE {
+		return err
+	}
+
+	return nil
 } 

internal/windowsansi/winansi_test.go renamed to internal/ansi/ansi_windows_test.go

@@ -1,6 +1,6 @@
 //go:build windows
 
-package windowsansi
+package ansi
 
 import (
 	"os"
@@ -11,17 +11,12 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const (
-	enableVirtualTerminalProcessing = 0x0004
-)
-
 // getConsoleMode is a helper to retrieve the current console mode for a given handle.
 func getConsoleMode(handle syscall.Handle) (uint32, error) {
 	var mode uint32
 	ret, _, err := syscall.NewLazyDLL("kernel32.dll").NewProc("GetConsoleMode").Call(uintptr(handle), uintptr(unsafe.Pointer(&mode)))
-	if ret == 0 {
-		// In Go 1.16+, err is not nil on failure. On older versions, it might be.
-		// So we return the error from the syscall call directly.
+	if ret == SYS_CALL_FAILURE {
+		// Note: err may be non-nil even on success, so we must check ret first.
 		return 0, err
 	}
 	return mode, nil
@@ -30,7 +25,7 @@ func getConsoleMode(handle syscall.Handle) (uint32, error) {
 // setConsoleMode is a helper to set the console mode for a given handle.
 func setConsoleMode(handle syscall.Handle, mode uint32) error {
 	ret, _, err := syscall.NewLazyDLL("kernel32.dll").NewProc("SetConsoleMode").Call(uintptr(handle), uintptr(mode))
-	if ret == 0 {
+	if ret == SYS_CALL_FAILURE {
 		return err
 	}
 	return nil
@@ -57,7 +52,8 @@ func TestEnable(t *testing.T) {
 	}
 
 	// Run the function we want to test.
-	Enable()
+	err = Enable()
+	require.NoError(t, err, "Enable() should not return an error in a real console")
 
 	// After running Enable(), check the console mode again to see if the flag was set.
 	newMode, err := getConsoleMode(handle)