Add support for struct slices

Author: pteich

README.md

@@ -68,6 +68,38 @@ err = configstruct.Save("config.yaml", &conf)
 
 ```
 
+## Struct slices (`[]struct`) via ENV and CLI (JSON)
+
+`[]struct` fields can now be populated from `env` and `cli` tags using JSON.
+
+```Go
+type Endpoint struct {
+    User string `json:"user" yaml:"user"`
+    Pass string `json:"pass" yaml:"pass"`
+    URL  string `json:"url" yaml:"url"`
+}
+
+type Config struct {
+    Endpoints []Endpoint `env:"MY_ENDPOINTS" cli:"endpoints" yaml:"endpoints" usage:"configured endpoints as JSON"`
+}
+```
+
+Supported JSON formats:
+
+- ENV (`MY_ENDPOINTS`):
+  - JSON array (primary): `[{"user":"u1","pass":"p1","url":"https://a"},{"user":"u2","pass":"p2","url":"https://b"}]`
+  - JSON object (optional shorthand for one entry): `{"user":"u1","pass":"p1","url":"https://a"}`
+- CLI (`-endpoints`):
+  - repeated JSON object flags:
+    - `-endpoints '{"user":"u1","pass":"p1","url":"https://a"}' -endpoints '{"user":"u2","pass":"p2","url":"https://b"}'`
+  - single JSON array:
+    - `-endpoints '[{"user":"u1","pass":"p1","url":"https://a"},{"user":"u2","pass":"p2","url":"https://b"}]'`
+
+Precedence is unchanged:
+
+- Default: CLI overrides ENV (`Parse`, `WithPrecedenceCli`).
+- `WithPrecedenceEnv()`: ENV overrides CLI.
+
 ## Usage with commands
 You can also define "commands" that can be used to execute callback functions. 
 The program with global flags and a command `count` should be called like this:

configstruct.go

@@ -3,6 +3,7 @@
 package configstruct // import "github.com/pteich/configstruct"
 
 import (
+	"encoding/json"
 	"flag"
 	"fmt"
 	"os"
@@ -117,6 +118,9 @@ func ParseWithFlagSet(flagSet *flag.FlagSet, cliArgs []string, c interface{}, op
 			cli := field.Tag.Get("cli")
 			cliAlt := field.Tag.Get("cliAlt")
 			usage := field.Tag.Get("usage")
+			structSliceValue := &structSliceFlag{
+				target: valueRef.Elem().FieldByName(field.Name),
+			}
 
 			setFlag := func(name string) error {
 				switch field.Type.Kind() {
@@ -128,6 +132,12 @@ func ParseWithFlagSet(flagSet *flag.FlagSet, cliArgs []string, c interface{}, op
 					flagSet.IntVar(valueRef.Elem().FieldByName(field.Name).Addr().Interface().(*int), name, int(value.Int()), usage)
 				case reflect.Float64:
 					flagSet.Float64Var(valueRef.Elem().FieldByName(field.Name).Addr().Interface().(*float64), name, value.Float(), usage)
+				case reflect.Slice:
+					if field.Type.Elem().Kind() == reflect.Struct {
+						flagSet.Var(structSliceValue, name, usage)
+						return nil
+					}
+					return fmt.Errorf("config cli type %s not implemented", field.Type.String())
 				default:
 					return fmt.Errorf("config cli type %s not implemented", field.Type.Kind())
 				}
@@ -157,6 +167,9 @@ func ParseWithFlagSet(flagSet *flag.FlagSet, cliArgs []string, c interface{}, op
 		for i := 0; i < confType.NumField(); i++ {
 			field := confType.Field(i)
 			env := field.Tag.Get("env")
+			if env == "" {
+				continue
+			}
 
 			envValue, found := os.LookupEnv(env)
 			if found {
@@ -178,8 +191,18 @@ func ParseWithFlagSet(flagSet *flag.FlagSet, cliArgs []string, c interface{}, op
 					if err == nil {
 						valueRef.Elem().FieldByName(field.Name).SetFloat(value)
 					}
+				case reflect.Slice:
+					if field.Type.Elem().Kind() != reflect.Struct {
+						return fmt.Errorf("config env type %s not implemented", field.Type.String())
+					}
+
+					sliceValue, err := decodeStructSliceJSON(envValue, field.Type)
+					if err != nil {
+						return fmt.Errorf("could not parse env %s for field %s: %w", env, field.Name, err)
+					}
+					valueRef.Elem().FieldByName(field.Name).Set(sliceValue)
 				default:
-					return fmt.Errorf("config env type %s not implemented", field.Type.Name())
+					return fmt.Errorf("config env type %s not implemented", field.Type.String())
 				}
 			}
 		}
@@ -221,6 +244,63 @@ func ParseWithFlagSet(flagSet *flag.FlagSet, cliArgs []string, c interface{}, op
 	return nil
 }
 
+type structSliceFlag struct {
+	target reflect.Value
+	seen   bool
+}
+
+func (f *structSliceFlag) String() string {
+	if !f.target.IsValid() {
+		return ""
+	}
+
+	b, err := json.Marshal(f.target.Interface())
+	if err != nil {
+		return ""
+	}
+
+	return string(b)
+}
+
+func (f *structSliceFlag) Set(value string) error {
+	if !f.target.IsValid() || !f.target.CanSet() {
+		return fmt.Errorf("slice field is not settable")
+	}
+
+	sliceValue, err := decodeStructSliceJSON(value, f.target.Type())
+	if err != nil {
+		return err
+	}
+
+	if !f.seen {
+		f.target.Set(reflect.MakeSlice(f.target.Type(), 0, 0))
+		f.seen = true
+	}
+
+	f.target.Set(reflect.AppendSlice(f.target, sliceValue))
+	return nil
+}
+
+func decodeStructSliceJSON(value string, fieldType reflect.Type) (reflect.Value, error) {
+	if fieldType.Kind() != reflect.Slice || fieldType.Elem().Kind() != reflect.Struct {
+		return reflect.Value{}, fmt.Errorf("type %s is not a slice of structs", fieldType.String())
+	}
+
+	sliceTarget := reflect.New(fieldType)
+	if err := json.Unmarshal([]byte(value), sliceTarget.Interface()); err == nil {
+		return sliceTarget.Elem(), nil
+	}
+
+	elemTarget := reflect.New(fieldType.Elem())
+	if err := json.Unmarshal([]byte(value), elemTarget.Interface()); err == nil {
+		sliceValue := reflect.MakeSlice(fieldType, 1, 1)
+		sliceValue.Index(0).Set(elemTarget.Elem())
+		return sliceValue, nil
+	}
+
+	return reflect.Value{}, fmt.Errorf("value is neither a JSON array nor a JSON object for %s", fieldType.String())
+}
+
 type structFlag struct {
 	name         string
 	description  string

configstruct_test.go

@@ -16,6 +16,16 @@ type testConfig struct {
 	FloatValue float64 `env:"CONFIGSTRUCT_FLOAT" cli:"floatValue" usage:"float value"`
 }
 
+type endpoint struct {
+	User string `json:"user" yaml:"user"`
+	Pass string `json:"pass" yaml:"pass"`
+	URL  string `json:"url" yaml:"url"`
+}
+
+type endpointConfig struct {
+	Endpoints []endpoint `env:"CONFIGSTRUCT_ENDPOINTS" cli:"endpoints" yaml:"endpoints"`
+}
+
 func TestParse(t *testing.T) {
 	t.Run("valid cli fields", func(t *testing.T) {
 		cliArgs := []string{"command", "-hostname=localhost", "-port=8080", "-debug=true", "-floatValue=100.5"}
@@ -247,6 +257,166 @@ func TestParse(t *testing.T) {
 		assert.Equal(t, tmpFile, conf.ConfigPath)
 	})
 
+	t.Run("env json array for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv("CONFIGSTRUCT_ENDPOINTS", `[{"user":"u1","pass":"p1","url":"https://a"},{"user":"u2","pass":"p2","url":"https://b"}]`)
+
+		cliArgs := []string{"command"}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 2)
+		assert.Equal(t, "u1", conf.Endpoints[0].User)
+		assert.Equal(t, "https://b", conf.Endpoints[1].URL)
+	})
+
+	t.Run("env json object for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv("CONFIGSTRUCT_ENDPOINTS", `{"user":"u1","pass":"p1","url":"https://a"}`)
+
+		cliArgs := []string{"command"}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 1)
+		assert.Equal(t, "u1", conf.Endpoints[0].User)
+		assert.Equal(t, "https://a", conf.Endpoints[0].URL)
+	})
+
+	t.Run("cli repeated json objects for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		cliArgs := []string{
+			"command",
+			`-endpoints={"user":"u1","pass":"p1","url":"https://a"}`,
+			`-endpoints={"user":"u2","pass":"p2","url":"https://b"}`,
+		}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{
+			Endpoints: []endpoint{{User: "default", Pass: "default", URL: "https://default"}},
+		}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 2)
+		assert.Equal(t, "u1", conf.Endpoints[0].User)
+		assert.Equal(t, "u2", conf.Endpoints[1].User)
+	})
+
+	t.Run("cli single json array for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		cliArgs := []string{
+			"command",
+			`-endpoints=[{"user":"u1","pass":"p1","url":"https://a"},{"user":"u2","pass":"p2","url":"https://b"}]`,
+		}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 2)
+		assert.Equal(t, "u1", conf.Endpoints[0].User)
+		assert.Equal(t, "u2", conf.Endpoints[1].User)
+	})
+
+	t.Run("default precedence cli over env for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv("CONFIGSTRUCT_ENDPOINTS", `[{"user":"env","pass":"env","url":"https://env"}]`)
+
+		cliArgs := []string{
+			"command",
+			`-endpoints={"user":"cli","pass":"cli","url":"https://cli"}`,
+		}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 1)
+		assert.Equal(t, "cli", conf.Endpoints[0].User)
+	})
+
+	t.Run("env precedence over cli for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv("CONFIGSTRUCT_ENDPOINTS", `[{"user":"env","pass":"env","url":"https://env"}]`)
+
+		cliArgs := []string{
+			"command",
+			`-endpoints={"user":"cli","pass":"cli","url":"https://cli"}`,
+		}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf, WithPrecedenceEnv())
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 1)
+		assert.Equal(t, "env", conf.Endpoints[0].User)
+	})
+
+	t.Run("yaml struct slice overridden by cli", func(t *testing.T) {
+		type Config struct {
+			Endpoints []endpoint `yaml:"endpoints" cli:"endpoints"`
+		}
+
+		tmpFile := "test_slice_yaml_override.yaml"
+		defer os.Remove(tmpFile)
+
+		err := Save(tmpFile, &Config{
+			Endpoints: []endpoint{{User: "yaml", Pass: "yaml", URL: "https://yaml"}},
+		})
+		assert.NoError(t, err)
+
+		conf := Config{}
+		cliArgs := []string{
+			"command",
+			`-endpoints={"user":"cli","pass":"cli","url":"https://cli"}`,
+		}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		err = ParseWithFlagSet(flagSet, cliArgs, &conf, WithYamlConfig(tmpFile))
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 1)
+		assert.Equal(t, "cli", conf.Endpoints[0].User)
+	})
+
+	t.Run("invalid env json returns error for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		os.Setenv("CONFIGSTRUCT_ENDPOINTS", `{"user":`)
+
+		cliArgs := []string{"command"}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.Error(t, err)
+	})
+
+	t.Run("invalid cli json returns error for struct slice", func(t *testing.T) {
+		os.Clearenv()
+		cliArgs := []string{"command", `-endpoints={"user":}`}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ContinueOnError)
+		conf := endpointConfig{}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.Error(t, err)
+	})
+
+	t.Run("struct slice keeps defaults when no input is set", func(t *testing.T) {
+		os.Clearenv()
+		cliArgs := []string{"command"}
+		flagSet := flag.NewFlagSet(cliArgs[0], flag.ExitOnError)
+		conf := endpointConfig{
+			Endpoints: []endpoint{{User: "default", Pass: "default", URL: "https://default"}},
+		}
+
+		err := ParseWithFlagSet(flagSet, cliArgs, &conf)
+		assert.NoError(t, err)
+		assert.Len(t, conf.Endpoints, 1)
+		assert.Equal(t, "default", conf.Endpoints[0].User)
+	})
+
 }
 
 // Example for using `configstruct` with default values.