fix: pointer-to-struct nil when no env vars, add envDefault/envSeparator/envExpand tags, camelCase conversion

- Pointer-to-struct fields now remain nil when no child env vars are set,
  matching kelseyhightower/envconfig behavior (Task #428)
- Parse envDefault tag as alias for default tag (Task #429)
- Parse envSeparator tag for custom slice separators (Task #429)
- Parse envExpand tag to expand $VAR references via os.ExpandEnv (Task #429)
- Convert CamelCase field names to UPPER_SNAKE_CASE (e.g. DatabaseURL -> DATABASE_URL)
  matching envconfig's word-boundary logic (Task #429)
- Fix empty string slice decode: HOSTS="" now produces []string{} not []string{""}
- 81 tests pass (was 66)

Author: mtingers

decoder.go

@@ -30,14 +30,15 @@ var (
 )
 
 // decode sets a reflect.Value from a string value.
+// separator is used for splitting slice values.
 // It returns a ParseError if decoding fails.
-func decode(fv reflect.Value, val string, fieldName string, envVar string) error {
+func decode(fv reflect.Value, val string, fieldName string, envVar string, separator string) error {
 	// Handle pointer: allocate and decode the element.
 	if fv.Kind() == reflect.Ptr {
 		if fv.IsNil() {
 			fv.Set(reflect.New(fv.Type().Elem()))
 		}
-		return decode(fv.Elem(), val, fieldName, envVar)
+		return decode(fv.Elem(), val, fieldName, envVar, separator)
 	}
 
 	// Check interfaces on pointer-to-value (to catch pointer receivers).
@@ -82,7 +83,7 @@ func decode(fv reflect.Value, val string, fieldName string, envVar string) error
 
 	// Slices.
 	if ft.Kind() == reflect.Slice {
-		return decodeSlice(fv, val, fieldName, envVar)
+		return decodeSlice(fv, val, fieldName, envVar, separator)
 	}
 
 	// Maps.
@@ -128,12 +129,16 @@ func decodeScalar(fv reflect.Value, val string, fieldName string, envVar string)
 	return nil
 }
 
-func decodeSlice(fv reflect.Value, val string, fieldName string, envVar string) error {
-	parts := strings.Split(val, ",")
+func decodeSlice(fv reflect.Value, val string, fieldName string, envVar string, separator string) error {
+	if val == "" {
+		fv.Set(reflect.MakeSlice(fv.Type(), 0, 0))
+		return nil
+	}
+	parts := strings.Split(val, separator)
 	slice := reflect.MakeSlice(fv.Type(), len(parts), len(parts))
 	for i, part := range parts {
 		part = strings.TrimSpace(part)
-		if err := decode(slice.Index(i), part, fieldName, envVar); err != nil {
+		if err := decode(slice.Index(i), part, fieldName, envVar, ","); err != nil {
 			return err
 		}
 	}
@@ -152,11 +157,11 @@ func decodeMap(fv reflect.Value, val string, fieldName string, envVar string) er
 				fmt.Errorf("expected key=value pair, got %q", pair))
 		}
 		key := reflect.New(fv.Type().Key()).Elem()
-		if err := decode(key, strings.TrimSpace(kv[0]), fieldName, envVar); err != nil {
+		if err := decode(key, strings.TrimSpace(kv[0]), fieldName, envVar, ","); err != nil {
 			return err
 		}
 		value := reflect.New(fv.Type().Elem()).Elem()
-		if err := decode(value, strings.TrimSpace(kv[1]), fieldName, envVar); err != nil {
+		if err := decode(value, strings.TrimSpace(kv[1]), fieldName, envVar, ","); err != nil {
 			return err
 		}
 		m.SetMapIndex(key, value)

envstruct.go

@@ -10,9 +10,23 @@ import (
 	"io"
 	"os"
 	"reflect"
+	"regexp"
 	"strings"
 )
 
+// gatherRegexp splits CamelCase into word groups.
+// Matches kelseyhightower/envconfig's word-boundary logic.
+var gatherRegexp = regexp.MustCompile("([^A-Z]+|[A-Z]+[^A-Z]*)")
+
+// camelToUpperSnake converts a CamelCase name to UPPER_SNAKE_CASE.
+func camelToUpperSnake(s string) string {
+	parts := gatherRegexp.FindAllString(s, -1)
+	for i, part := range parts {
+		parts[i] = strings.ToUpper(part)
+	}
+	return strings.Join(parts, "_")
+}
+
 // Process populates the struct pointed to by spec with values from
 // environment variables. The prefix is prepended to each field name
 // (or tag override) when looking up environment variables.
@@ -25,7 +39,8 @@ func Process(prefix string, spec interface{}) error {
 	if rv.Kind() != reflect.Struct {
 		return fmt.Errorf("envstruct: spec must be a pointer to a struct")
 	}
-	return processStruct(prefix, rv)
+	_, err := processStruct(prefix, rv)
+	return err
 }
 
 // isStructField returns true if the field type is a struct that should be
@@ -51,9 +66,10 @@ func isStructField(ft reflect.Type) bool {
 	return true
 }
 
-func processStruct(prefix string, rv reflect.Value) error {
+func processStruct(prefix string, rv reflect.Value) (bool, error) {
 	rt := rv.Type()
 	var errs []error
+	anySet := false
 	for i := 0; i < rt.NumField(); i++ {
 		f := rt.Field(i)
 		fv := rv.Field(i)
@@ -64,7 +80,7 @@ func processStruct(prefix string, rv reflect.Value) error {
 		}
 
 		// Build the env var name component from the field name.
-		envName := strings.ToUpper(f.Name)
+		envName := camelToUpperSnake(f.Name)
 		spec := parseTag(f, envName)
 		if spec.Ignored {
 			continue
@@ -86,15 +102,22 @@ func processStruct(prefix string, rv reflect.Value) error {
 				// Pointer-to-struct: allocate temp, recurse, assign only if
 				// at least one env var was set.
 				tmp := reflect.New(f.Type.Elem())
-				if err := processStruct(nestedPrefix, tmp.Elem()); err != nil {
+				set, err := processStruct(nestedPrefix, tmp.Elem())
+				if err != nil {
 					errs = append(errs, err)
-				} else {
+				}
+				if set {
 					fv.Set(tmp)
+					anySet = true
 				}
 			} else {
-				if err := processStruct(nestedPrefix, fv); err != nil {
+				set, err := processStruct(nestedPrefix, fv)
+				if err != nil {
 					errs = append(errs, err)
 				}
+				if set {
+					anySet = true
+				}
 			}
 			continue
 		}
@@ -123,12 +146,25 @@ func processStruct(prefix string, rv reflect.Value) error {
 			continue
 		}
 
+		// Apply envExpand: expand $VAR references in the value.
+		if spec.Expand {
+			val = os.ExpandEnv(val)
+		}
+
+		// Determine separator for slice decoding.
+		sep := spec.Separator
+		if sep == "" {
+			sep = ","
+		}
+
 		// Decode and set the field value.
-		if err := decode(fv, val, f.Name, key); err != nil {
+		if err := decode(fv, val, f.Name, key, sep); err != nil {
 			errs = append(errs, err)
+		} else {
+			anySet = true
 		}
 	}
-	return errors.Join(errs...)
+	return anySet, errors.Join(errs...)
 }
 
 // MustProcess is like Process but panics on error.

envstruct_test.go

@@ -333,3 +333,192 @@ func TestMultipleErrorsCollected(t *testing.T) {
 		t.Fatalf("expected both HOST and PORT errors, got: %s", errStr)
 	}
 }
+
+// --- Pointer-to-struct nil when no env vars set (Task #428) ---
+
+func TestPointerToStructNilWhenNoEnvVars(t *testing.T) {
+	type DB struct {
+		Host string
+		Port int
+	}
+	type Config struct {
+		Database *DB
+	}
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Database != nil {
+		t.Fatalf("expected nil pointer when no env vars set, got %+v", c.Database)
+	}
+}
+
+func TestPointerToStructSetWhenPartialEnvVars(t *testing.T) {
+	type DB struct {
+		Host string
+		Port int
+	}
+	type Config struct {
+		Database *DB
+	}
+	setEnv(t, "APP_DATABASE_HOST", "partial.local")
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Database == nil {
+		t.Fatal("expected non-nil pointer when env var is set")
+	}
+	if c.Database.Host != "partial.local" {
+		t.Fatalf("expected 'partial.local', got %q", c.Database.Host)
+	}
+}
+
+// --- CamelCase to UPPER_SNAKE_CASE (Task #429) ---
+
+func TestCamelCaseFieldName(t *testing.T) {
+	type Config struct {
+		DatabaseURL string
+	}
+	setEnv(t, "APP_DATABASE_URL", "postgres://localhost")
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.DatabaseURL != "postgres://localhost" {
+		t.Fatalf("expected 'postgres://localhost', got %q", c.DatabaseURL)
+	}
+}
+
+func TestCamelCaseMultiWord(t *testing.T) {
+	type Config struct {
+		MaxRetryCount int
+	}
+	setEnv(t, "MAX_RETRY_COUNT", "5")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.MaxRetryCount != 5 {
+		t.Fatalf("expected 5, got %d", c.MaxRetryCount)
+	}
+}
+
+// --- envDefault tag (Task #429) ---
+
+func TestEnvDefaultTag(t *testing.T) {
+	type Config struct {
+		Port int `envDefault:"5000"`
+	}
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Port != 5000 {
+		t.Fatalf("expected 5000, got %d", c.Port)
+	}
+}
+
+func TestEnvDefaultOverriddenByEnv(t *testing.T) {
+	type Config struct {
+		Port int `envDefault:"5000"`
+	}
+	setEnv(t, "APP_PORT", "9090")
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Port != 9090 {
+		t.Fatalf("expected 9090, got %d", c.Port)
+	}
+}
+
+func TestDefaultTagTakesPrecedenceOverEnvDefault(t *testing.T) {
+	type Config struct {
+		Port int `default:"3000" envDefault:"5000"`
+	}
+	var c Config
+	if err := Process("APP", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Port != 3000 {
+		t.Fatalf("expected 3000 (default takes precedence), got %d", c.Port)
+	}
+}
+
+// --- envSeparator tag (Task #429) ---
+
+func TestEnvSeparatorTag(t *testing.T) {
+	type Config struct {
+		Paths []string `envSeparator:":"`
+	}
+	setEnv(t, "PATHS", "/usr/bin:/usr/local/bin:/home/user/bin")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(c.Paths) != 3 || c.Paths[0] != "/usr/bin" || c.Paths[2] != "/home/user/bin" {
+		t.Fatalf("expected 3 paths, got %v", c.Paths)
+	}
+}
+
+func TestEnvSeparatorDefaultComma(t *testing.T) {
+	type Config struct {
+		Tags []string
+	}
+	setEnv(t, "TAGS", "a,b,c")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(c.Tags) != 3 {
+		t.Fatalf("expected 3 tags, got %v", c.Tags)
+	}
+}
+
+// --- envExpand tag (Task #429) ---
+
+func TestEnvExpandTag(t *testing.T) {
+	type Config struct {
+		DataDir string `envExpand:"true"`
+	}
+	setEnv(t, "HOME", "/home/testuser")
+	setEnv(t, "DATA_DIR", "$HOME/data")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.DataDir != "/home/testuser/data" {
+		t.Fatalf("expected '/home/testuser/data', got %q", c.DataDir)
+	}
+}
+
+func TestEnvExpandDisabledByDefault(t *testing.T) {
+	type Config struct {
+		Val string
+	}
+	setEnv(t, "VAL", "$HOME/data")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if c.Val != "$HOME/data" {
+		t.Fatalf("expected literal '$HOME/data', got %q", c.Val)
+	}
+}
+
+// --- Empty slice decode ---
+
+func TestDecodeEmptySlice(t *testing.T) {
+	type Config struct {
+		Hosts []string
+	}
+	setEnv(t, "HOSTS", "")
+	var c Config
+	if err := Process("", &c); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(c.Hosts) != 0 {
+		t.Fatalf("expected empty slice, got %v", c.Hosts)
+	}
+}

tags.go

@@ -13,6 +13,8 @@ type fieldSpec struct {
 	HasDefault   bool
 	Ignored      bool
 	Description  string
+	Separator    string // custom separator for slices (envSeparator tag)
+	Expand       bool   // expand env var references via os.ExpandEnv (envExpand tag)
 }
 
 // parseTag extracts a fieldSpec from a struct field's tags.
@@ -44,10 +46,23 @@ func parseTag(f reflect.StructField, fieldName string) fieldSpec {
 		}
 	}
 
-	// Check default tag.
+	// Check default tag, then envDefault for envconfig compat.
 	if defVal, ok := f.Tag.Lookup("default"); ok {
 		spec.DefaultValue = defVal
 		spec.HasDefault = true
+	} else if defVal, ok := f.Tag.Lookup("envDefault"); ok {
+		spec.DefaultValue = defVal
+		spec.HasDefault = true
+	}
+
+	// Check envSeparator tag (custom slice separator).
+	if sep, ok := f.Tag.Lookup("envSeparator"); ok {
+		spec.Separator = sep
+	}
+
+	// Check envExpand tag (expand env var references in values).
+	if exp, ok := f.Tag.Lookup("envExpand"); ok && exp == "true" {
+		spec.Expand = true
 	}
 
 	// Check desc tag.