feat: add explicit typings for keys (#14)

Author: zepatrik

viper.go

@@ -206,6 +206,7 @@ type Viper struct {
 	config         map[string]interface{}
 	override       map[string]interface{}
 	defaults       map[string]interface{}
+	types          map[string]interface{}
 	kvstore        map[string]interface{}
 	pflags         map[string]FlagValue
 	env            map[string]string
@@ -237,6 +238,7 @@ func New() *Viper {
 	v.config = make(map[string]interface{})
 	v.override = make(map[string]interface{})
 	v.defaults = make(map[string]interface{})
+	v.types = make(map[string]interface{})
 	v.kvstore = make(map[string]interface{})
 	v.previousValues = make(map[string]interface{})
 	v.pflags = make(map[string]FlagValue)
@@ -849,44 +851,49 @@ func (v *Viper) Get(key string) interface{} {
 		return nil
 	}
 
-	if v.typeByDefValue {
-		// TODO(bep) this branch isn't covered by a single test.
-		valType := val
+	valType := val
 
-		v.lock.RLock()
-		path := strings.Split(lcaseKey, v.keyDelim)
-		defVal := v.searchMap(v.defaults, path)
-		if defVal != nil {
-			valType = defVal
-		}
+	v.lock.RLock()
+	path := strings.Split(lcaseKey, v.keyDelim)
+	var valT interface{}
+	if typeVal := v.searchMap(v.types, path); typeVal != nil {
+		valT = typeVal
+	} else if v.typeByDefValue {
+		valT = v.searchMap(v.defaults, path)
+	} else {
+		// no typeVal set and typeDefByValue also not set - no conversion needed
 		v.lock.RUnlock()
+		return val
+	}
+	v.lock.RUnlock()
 
-		switch valType.(type) {
-		case bool:
-			val = cast.ToBool(val)
-		case string:
-			return cast.ToString(val)
-		case int32, int16, int8, int:
-			return cast.ToInt(val)
-		case uint:
-			return cast.ToUint(val)
-		case uint32:
-			return cast.ToUint32(val)
-		case uint64:
-			return cast.ToUint64(val)
-		case int64:
-			return cast.ToInt64(val)
-		case float64, float32:
-			return cast.ToFloat64(val)
-		case time.Time:
-			return cast.ToTime(val)
-		case time.Duration:
-			return cast.ToDuration(val)
-		case []string:
-			return cast.ToStringSlice(val)
-		case []int:
-			return cast.ToIntSlice(val)
-		}
+	valType = valT
+
+	switch valType.(type) {
+	case bool:
+		val = cast.ToBool(val)
+	case string:
+		return cast.ToString(val)
+	case int32, int16, int8, int:
+		return cast.ToInt(val)
+	case uint:
+		return cast.ToUint(val)
+	case uint32:
+		return cast.ToUint32(val)
+	case uint64:
+		return cast.ToUint64(val)
+	case int64:
+		return cast.ToInt64(val)
+	case float64, float32:
+		return cast.ToFloat64(val)
+	case time.Time:
+		return cast.ToTime(val)
+	case time.Duration:
+		return cast.ToDuration(val)
+	case []string:
+		return cast.ToStringSlice(val)
+	case []int:
+		return cast.ToIntSlice(val)
 	}
 
 	return val
@@ -1428,21 +1435,14 @@ func (v *Viper) InConfig(key string) bool {
 	return exists
 }
 
-// SetDefault sets the default value for this key.
-// SetDefault is case-insensitive for a key.
-// Default only used when no value is provided by the user via flag, config or ENV.
-func SetDefault(key string, value interface{}) { v.SetDefault(key, value) }
-func (v *Viper) SetDefault(key string, value interface{}) {
-	// We're clearing the whole cache because nested keys may cause issues if only the key is evicted.
-
-	// If alias passed in, then set the proper default
+func (v *Viper) setInMap(key string, value interface{}, target map[string]interface{}) {
 	key = v.realKey(strings.ToLower(key))
 	value = toCaseInsensitiveValue(value)
 
 	v.lock.RLock()
 	path := strings.Split(key, v.keyDelim)
 	lastKey := strings.ToLower(path[len(path)-1])
-	deepestMap := deepSearch(v.defaults, path[0:len(path)-1])
+	deepestMap := deepSearch(target, path[0:len(path)-1])
 	v.lock.RUnlock()
 
 	v.lock.Lock()
@@ -1452,29 +1452,30 @@ func (v *Viper) SetDefault(key string, value interface{}) {
 	v.lock.Unlock()
 }
 
+// SetDefault sets the default value for this key.
+// SetDefault is case-insensitive for a key.
+// Default only used when no value is provided by the user via flag, config or ENV.
+func SetDefault(key string, value interface{}) { v.SetDefault(key, value) }
+func (v *Viper) SetDefault(key string, value interface{}) {
+	v.setInMap(key, value, v.defaults)
+}
+
+// SetType sets the type for this key.
+// This type is used for type conversions, e.g. a slice from an env var
+// This function allows the default to be nil while still enabling those type conversions configured
+// through SetTypeByDefaultValue
+func SetType(key string, t interface{}) { v.SetType(key, t) }
+func (v *Viper) SetType(key string, t interface{}) {
+	v.setInMap(key, t, v.types)
+}
+
 // Set sets the value for the key in the override register.
 // Set is case-insensitive for a key.
 // Will be used instead of values obtained via
 // flags, config file, ENV, default, or key/value store.
 func Set(key string, value interface{}) { v.Set(key, value) }
 func (v *Viper) Set(key string, value interface{}) {
-	// We're clearing the whole cache because nested keys may cause issues if only the key is evicted.
-
-	// If alias passed in, then set the proper override
-	key = v.realKey(strings.ToLower(key))
-	value = toCaseInsensitiveValue(value)
-
-	v.lock.RLock()
-	path := strings.Split(key, v.keyDelim)
-	lastKey := strings.ToLower(path[len(path)-1])
-	deepestMap := deepSearch(v.override, path[0:len(path)-1])
-	v.lock.RUnlock()
-
-	// set innermost value
-	v.lock.Lock()
-	v.cache.Clear()
-	deepestMap[lastKey] = value
-	v.lock.Unlock()
+	v.setInMap(key, value, v.override)
 }
 
 // ReadInConfig will discover and load the configuration file from disk

viper_test.go

@@ -957,22 +957,23 @@ func TestBindPFlagsIntSlice(t *testing.T) {
 func TestBindPFlag(t *testing.T) {
 	var testString = "testing"
 	var testValue = newStringValue(testString, &testString)
+	testViperKey := "testvalue"
 
 	flag := &pflag.Flag{
 		Name:    "testflag",
 		Value:   testValue,
 		Changed: false,
 	}
 
-	BindPFlag("testvalue", flag)
+	require.NoError(t, BindPFlag(testViperKey, flag))
 
-	assert.Equal(t, testString, Get("testvalue"))
+	assert.Equal(t, testString, Get(testViperKey))
 
-	BindPFlag("testvalue", flag) // hack for pflag usage
-	flag.Value.Set("testing_mutate")
+	require.NoError(t, BindPFlag("testvalue", flag)) // hack for pflag usage
+	require.NoError(t, flag.Value.Set("testing_mutate"))
 	flag.Changed = true // hack for pflag usage
 
-	assert.Equal(t, "testing_mutate", Get("testvalue"))
+	assert.Equal(t, "testing_mutate", Get(testViperKey))
 }
 
 func TestBoundCaseSensitivity(t *testing.T) {
@@ -2338,6 +2339,47 @@ func TestConfigChangedAt(t *testing.T) {
 	})
 }
 
+func TestTypeConversion(t *testing.T) {
+	t.Run("case=converts string to string slice length 1", func(t *testing.T) {
+		Reset()
+
+		key := "foo"
+		SetType(key, []string{})
+		Set(key, "bar")
+		assert.Equal(t, []string{"bar"}, Get(key))
+	})
+
+	t.Run("case=converts string to string slice length 3", func(t *testing.T) {
+		Reset()
+
+		key := "key"
+		SetType(key, []string{})
+		Set(key, "a b c")
+		assert.Equal(t, []string{"a", "b", "c"}, Get(key))
+	})
+
+	t.Run("case=SetType has precedence over default", func(t *testing.T) {
+		Reset()
+
+		key := "test_key"
+		SetTypeByDefaultValue(true)
+		SetDefault(key, 1)
+		SetType(key, []string{})
+		Set(key, "foo bar")
+		assert.Equal(t, []string{"foo", "bar"}, Get(key))
+	})
+
+	t.Run("case=type conversion from default value works aswell", func(t *testing.T) {
+		Reset()
+
+		key := "key"
+		SetDefault(key, []string{})
+		SetTypeByDefaultValue(true)
+		Set(key, "a b c")
+		assert.Equal(t, []string{"a", "b", "c"}, Get(key))
+	})
+}
+
 func TestRace(t *testing.T) {
 	Reset()