[#24] Provide FieldSetter interface to support custom implementations (#25)

Author: BoRuDar

README.md

@@ -20,7 +20,7 @@ Supported types:
 - `uint`, `uint8`, `uint16`, `uint32`, `uint64` + slices of these types
 - `*uint`, `*uint8`, `*uint16`, `*uint32`, `*uint64` + slices of these types
 - `float32`, `float64` + slices of these types
-- `*float32`, `*float64`
+- `*float32`, `*float64` + slices of these types
 - `time.Duration` from strings like `12ms`, `2s` etc.
 - embedded structs and pointers to structs
 
@@ -116,6 +116,30 @@ type Provider interface {
 }
 ```
 
+### FieldSetter interface
+You can define how to set fields with any custom types: 
+```go
+type FieldSetter interface {
+	SetField(field reflect.StructField, val reflect.Value, valStr string) error
+}
+```
+Example:
+```go
+type ipTest net.IP
+
+func (it *ipTest) SetField(_ reflect.StructField, val reflect.Value, valStr string) error {
+	i := ipTest(net.ParseIP(valStr))
+
+	if val.Kind() == reflect.Pointer {
+		val.Set(reflect.ValueOf(&i))
+	} else {
+		val.Set(reflect.ValueOf(i))
+	}
+
+	return nil
+}
+```
+
 ### Default provider
 Looks for `default` tag and set value from it:
 ```go

configurator.go

@@ -106,8 +106,7 @@ func (c *Configurator) applyProviders(field reflect.StructField, v reflect.Value
 	}
 
 	for _, provider := range c.providers {
-		err := provider.Provide(field, v)
-		if err == nil {
+		if provider.Provide(field, v) == nil {
 			return
 		}
 	}

configurator_test.go

@@ -1,6 +1,7 @@
 package configuration
 
 import (
+	"net"
 	"os"
 	"testing"
 	"time"
@@ -39,7 +40,8 @@ func TestConfigurator(t *testing.T) {
 			IntSlice   []int64  `default:"3; 4"`
 			unexported string   `xml:"ignored"`
 		}
-		URLs []*string `default:"http://localhost:3000;1.2.3.4:8080"`
+		URLs   []*string `default:"http://localhost:3000;1.2.3.4:8080"`
+		HostIP ipTest    `default:"127.0.0.3"`
 	}{}
 
 	configurator := New(
@@ -73,6 +75,8 @@ func TestConfigurator(t *testing.T) {
 	assert(t, []int64{3, 4}, cfg.Obj.IntSlice)
 	assert(t, time.Millisecond*100, cfg.ObjPtr.HundredMS)
 
+	assert(t, net.ParseIP("127.0.0.3"), net.IP(cfg.HostIP))
+
 	for i := range expectedURLs {
 		assert(t, expectedURLs[i], *cfg.URLs[i])
 	}

fieldSetter.go

@@ -10,12 +10,27 @@ import (
 
 const sliceSeparator = ";"
 
-// SetField sets field with `valStr` value (converts to the proper type beforehand)
-func SetField(field reflect.StructField, v reflect.Value, valStr string) error {
-	if v.Kind() == reflect.Ptr {
-		return setPtrValue(field.Type, v, valStr)
+type FieldSetter interface {
+	SetField(field reflect.StructField, val reflect.Value, valStr string) error
+}
+
+// SetField sets field with `valStr` value (and converts it into the proper type beforehand)
+func SetField(field reflect.StructField, val reflect.Value, valStr string) error {
+	if val.CanInterface() {
+		if fs, ok := val.Addr().Interface().(FieldSetter); ok {
+			return fs.SetField(field, val, valStr)
+		}
+
+		if fs, ok := val.Interface().(FieldSetter); ok {
+			return fs.SetField(field, val, valStr)
+		}
+	}
+
+	if val.Kind() == reflect.Pointer {
+		return setPtrValue(field.Type, val, valStr)
 	}
-	return setValue(field.Type, v, valStr)
+
+	return setValue(field.Type, val, valStr)
 }
 
 func setValue(t reflect.Type, v reflect.Value, val string) (err error) {

fieldStetter_test.go

@@ -1,8 +1,10 @@
 package configuration
 
 import (
+	"net"
 	"reflect"
 	"strconv"
+	"strings"
 	"testing"
 	"time"
 )
@@ -425,3 +427,80 @@ func TestSetValue_IntPtrSlice_Err(t *testing.T) {
 		t.Fatalf("wrong error: %v", err)
 	}
 }
+
+type testCfgSetField struct {
+	HostOne *ipTest `default:"127.0.0.1"`
+	HostTwo ipTest  `default:"127.0.0.2"`
+	Hosts   ipsTest `default:"10.0.0.1,10.0.0.2"`
+	NameOne string  `default:"one"`
+	NameTwo *string `default:"two"`
+}
+
+type ipTest net.IP
+
+func (it *ipTest) SetField(_ reflect.StructField, val reflect.Value, valStr string) error {
+	i := ipTest(net.ParseIP(valStr))
+
+	if val.Kind() == reflect.Pointer {
+		val.Set(reflect.ValueOf(&i))
+	} else {
+		val.Set(reflect.ValueOf(i))
+	}
+
+	return nil
+}
+
+type ipsTest []ipTest
+
+func (it *ipsTest) SetField(sf reflect.StructField, val reflect.Value, valStr string) error {
+	var (
+		strIPs = strings.Split(valStr, ",")
+		ips    = make(ipsTest, len(strIPs))
+	)
+
+	for i, ip := range strIPs {
+		if err := ips[i].SetField(sf, reflect.ValueOf(&ips[i]).Elem(), ip); err != nil {
+			return err
+		}
+	}
+
+	if val.Kind() == reflect.Pointer {
+		val.Set(reflect.ValueOf(&ips))
+	} else {
+		val.Set(reflect.ValueOf(ips))
+	}
+
+	return nil
+}
+
+type stringTest string
+
+func (st *stringTest) SetField(_ reflect.StructField, val reflect.Value, valStr string) error {
+	s := stringTest(valStr)
+
+	if val.Kind() == reflect.Pointer {
+		val.Set(reflect.ValueOf(&s))
+	} else {
+		val.Set(reflect.ValueOf(s))
+	}
+
+	return nil
+}
+
+func Test_CustomFieldSetter(t *testing.T) {
+	var cfg testCfgSetField
+
+	err := FromEnvAndDefault(&cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assert(t, "127.0.0.1", net.IP(*cfg.HostOne).String())
+	assert(t, "127.0.0.2", net.IP(cfg.HostTwo).String())
+	assert(t, "one", cfg.NameOne)
+	assert(t, "two", *cfg.NameTwo)
+	assert(t, ipsTest([]ipTest{
+		ipTest(net.ParseIP("10.0.0.1")),
+		ipTest(net.ParseIP("10.0.0.2")),
+	}), cfg.Hosts)
+}