Error handling (#12)

* Replace osExit with configurable error handlign

* fix fallback to default value

* update callback signature and add comments

* improve coverage

* improve coverage

* update readme

* update comment

Author: atelpis

Readme.md

@@ -25,14 +25,13 @@ straightforward API, making configuration predictable and easy to manage.
 
 ## Features
 
-- **Type-safe**: Generics-based implementation, no reflection
-- **Container-optimized**: Unified API for both environment variables and cmd flags
-- **Comprehensive support**: Built-in parsing for all widely used types
-- **Flexible**: Supports configurable slices, binary decoders,
-  and JSON values
-- **Extensible**: Easily add custom parsers
-- **Minimalistic**: Clean, straightforward API
-- **Lightweight**: Zero external dependencies
+- **Type-safe** – Generics-based design, no runtime reflection
+- **Container-optimized** – Unified API for env vars and CLI flags
+- **Flexible** – Handles primitives, slices, JSON, and binary formats
+- **Extensible** – Custom parsers can be added easily
+- **Error handling** – Built-in handlers with custom callback support
+- **Secure & lightweight** – No external dependencies, suitable for security-sensitive
+  applications
 
 ## Usage
 

binding.go

@@ -7,7 +7,7 @@ flag > environment variable > default value. Both environment variables and flag
 
 Flag parsing is handled by the standard library's flag package via the CommandLine flag set.
 Like the flag package, errors encountered during environment variable parsing will cause
-the program to exit with status code 2.
+the program to exit with status code 2 by default, but the error handler can be predefined.
 
 # Example usage:
 
@@ -31,7 +31,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"flag"
-	"fmt"
 	"net"
 	"net/url"
 	"os"
@@ -387,26 +386,18 @@ func handleVar[T any](b binding, ptr *T, parser func(string) (T, error)) {
 	if envVal := os.Getenv(b.envName); envVal != "" {
 		v, err := parser(envVal)
 		if err != nil {
-			fmt.Fprintf(
-				flag.CommandLine.Output(),
-				"Unable to parse env-variable %s as type %T\n",
-				b.envName,
-				*ptr,
-			)
-
-			// os.Exit(2) replicates the default error handling behavior of flag.CommandLine
-			if !isTestEnv {
-				os.Exit(2)
-			}
+			handleError(err, ptr, envVal, b.envName, "")
+		} else {
+			*ptr = v
 		}
-		*ptr = v
 	}
 
 	if b.flagName != "" {
 		flag.Func(b.flagName, b.flagUsage, func(s string) error {
 			parsed, err := parser(s)
 			if err != nil {
-				return err
+				handleError(err, ptr, s, "", b.flagName)
+				return nil
 			}
 
 			*ptr = parsed
@@ -420,18 +411,10 @@ func handleSlice[T any](b binding, ptr *[]T, parser func(string) (T, error)) {
 		for _, v := range strings.Split(envVal, b.sliceSep) {
 			parsed, err := parser(v)
 			if err != nil {
-				fmt.Fprintf(
-					flag.CommandLine.Output(),
-					"Unable to parse env-variable %s as type %T\n",
-					b.envName,
-					*ptr,
-				)
-
-				// os.Exit(2) replicates the default error handling behavior of flag.CommandLine
-				if !isTestEnv {
-					os.Exit(2)
-				}
+				handleError(err, ptr, envVal, b.envName, "")
+				continue
 			}
+
 			*ptr = append(*ptr, parsed)
 		}
 	}
@@ -441,7 +424,8 @@ func handleSlice[T any](b binding, ptr *[]T, parser func(string) (T, error)) {
 			for _, v := range strings.Split(s, b.sliceSep) {
 				parsed, err := parser(v)
 				if err != nil {
-					return err
+					handleError(err, ptr, s, "", b.flagName)
+					continue
 				}
 
 				*ptr = append(*ptr, parsed)
@@ -451,5 +435,3 @@ func handleSlice[T any](b binding, ptr *[]T, parser func(string) (T, error)) {
 		})
 	}
 }
-
-var isTestEnv bool

binding_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestBind(t *testing.T) {
-	isTestEnv = true
+	ErrorHandlerFunc = OnErrorLogAndContinue
 
 	type tc struct {
 		name string
@@ -464,7 +464,7 @@ func TestBind(t *testing.T) {
 
 				Var(&target).WithDefault(80).Bind("PORT", "port")
 
-				return toSlice(func() { checkVal(t, uint(0), target) })
+				return toSlice(func() { checkVal(t, uint(80), target) })
 			},
 		},
 		{
@@ -489,7 +489,7 @@ func TestBind(t *testing.T) {
 
 				Var(&target).BindEnv("PORTS")
 
-				return toSlice(func() { checkSlice(t, []int{0, 0}, target) })
+				return toSlice(func() { checkSlice(t, []int{}, target) })
 			},
 		},
 		{
@@ -527,7 +527,7 @@ func TestBind(t *testing.T) {
 				}
 				VarFunc(&target, parser).WithDefault(10).Bind("MY_FORMAT", "my-format")
 
-				return toSlice(func() { checkVal(t, 0, target) })
+				return toSlice(func() { checkVal(t, 10, target) })
 			},
 		},
 		{
@@ -577,6 +577,41 @@ func TestBind(t *testing.T) {
 	}
 }
 
+func TestErrroHandling(t *testing.T) {
+	t.Run("Err ignore", func(t *testing.T) {
+		ErrorHandlerFunc = OnErrorIgnore
+
+		reset()
+		var target int
+
+		os.Setenv("ENV_ERR", "one")
+		BindVar(&target, "ENV_ERR", "")
+		Parse()
+	})
+
+	t.Run("Err exit", func(t *testing.T) {
+		var exitStatus int
+
+		oldFunc := osExitFunc
+		osExitFunc = func(code int) {
+			exitStatus = code
+		}
+		defer func() { osExitFunc = oldFunc }()
+
+		ErrorHandlerFunc = OnErrorExit
+
+		reset()
+		var target int
+
+		os.Setenv("ENV_ERR", "one")
+		BindVar(&target, "ENV_ERR", "")
+		Parse()
+
+		checkVal(t, 2, exitStatus)
+	})
+
+}
+
 func checkVal[A comparable](t *testing.T, want A, got A) {
 	t.Helper()
 

err.go

@@ -0,0 +1,43 @@
+package enflag
+
+import (
+	"flag"
+	"fmt"
+	"os"
+)
+
+// ErrorHandlerFunc is a function called after a value parser returns an error.
+// See predefined options: OnErrorExit, OnErrorIgnore, and OnErrorLogAndContinue.
+// It can also be replaced with a custom handler.
+var ErrorHandlerFunc = OnErrorExit
+
+// OnErrorExit prints the error and exits with status code 2.
+var OnErrorExit = func(err error, rawVal string, target any, envName string, flagName string) {
+	OnErrorLogAndContinue(err, rawVal, target, envName, flagName)
+	osExitFunc(2)
+}
+
+// OnErrorIgnore silently ignores the error.
+// If a default value is specified, it will be used.
+var OnErrorIgnore = func(err error, rawVal string, target any, envName string, flagName string) {}
+
+// OnErrorLogAndContinue prints the error message but continues execution.
+// If a default value is specified, it will be used.
+var OnErrorLogAndContinue = func(err error, rawVal string, target any, envName string, flagName string) {
+	_, _ = err, rawVal
+
+	var msg string
+	if envName != "" {
+		msg = fmt.Sprintf("unable to parse env-variable %q as type %T\n", envName, target)
+	} else if flagName != "" {
+		msg = fmt.Sprintf("unable to parse flag %q as type %T\n", flagName, target)
+	}
+
+	flag.CommandLine.Output().Write([]byte(msg))
+}
+
+func handleError[T any](err error, target *T, rawVal, envName string, flagName string) {
+	ErrorHandlerFunc(err, rawVal, *target, envName, flagName)
+}
+
+var osExitFunc = os.Exit