Added support converting unmarshalled configs to interface{}

CHANGELOG.md

@@ -7,6 +7,10 @@ to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+### Added
+
+- Support converting unmarshalled configurations to `interface{}`.
+
 ## [1.3.0] - 2024-08-26
 
 ### Removed

internal/convert/converter.go

@@ -42,7 +42,7 @@ func (c Converter) Convert(from, to any) error {
 	return c.convert("", from, toVal)
 }
 
-func (c Converter) convert(name string, from any, toVal reflect.Value) error { //nolint:cyclop
+func (c Converter) convert(name string, from any, toVal reflect.Value) error { //nolint:cyclop,funlen
 	if from == nil {
 		return nil // Do nothing if from is nil.
 	}
@@ -91,6 +91,10 @@ func (c Converter) convert(name string, from any, toVal reflect.Value) error { /
 		return c.convertString(name, fromVal, toVal)
 	case toVal.Kind() == reflect.Struct:
 		return c.convertStruct(name, fromVal, toVal)
+	case toVal.Kind() == reflect.Interface: // Right after all other checks.
+		toVal.Set(fromVal)
+
+		return nil
 	default:
 		// If it reached here then it weren't able to convert it.
 		return fmt.Errorf("%s: unsupported type: %s", name, toVal.Kind()) //nolint:err113

internal/convert/converter_test.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/nil-go/konf/internal/assert"
 	"github.com/nil-go/konf/internal/convert"
+	"github.com/nil-go/konf/internal/maps"
 )
 
 func TestConverter(t *testing.T) { //nolint:maintidx
@@ -835,34 +836,39 @@ func TestConverter(t *testing.T) { //nolint:maintidx
 				}),
 			},
 			from: map[string]any{
-				"Enum":         "sky",
-				"OuterField":   "outer",
-				"PrivateField": "private",
-				"InnerField":   "squash",
-				"Inner":        map[string]any{"InnerField": "inner"},
+				"Enum":           "sky",
+				"OuterField":     "outer",
+				"PrivateField":   "private",
+				"InterfaceField": "interface{}",
+				"InnerField":     "squash",
+				"Inner":          map[string]any{"InnerField": "inner"},
 			},
 			to: pointer(OuterStruct{}),
 			expected: pointer(OuterStruct{
-				Enum:        Sky,
-				OuterField:  "outer",
-				InnerStruct: InnerStruct{InnerField: "squash"},
-				Inner:       &InnerStruct{InnerField: "inner"},
+				Enum:           Sky,
+				OuterField:     "outer",
+				InterfaceField: "interface{}",
+				InnerStruct:    InnerStruct{InnerField: "squash"},
+				Inner:          &InnerStruct{InnerField: "inner"},
 			}),
 		},
 		{
 			description: "map to struct (with keyMap)",
 			opts: []convert.Option{
 				convert.WithKeyMapper(strings.ToLower),
 			},
-			from: map[string]string{"innerfield": "inner"},
+			from: map[string]string{"innerfield": "inner", "interfacefield": "interface{}"},
 			to: pointer(struct {
-				InnerField string
+				InnerField     string
+				InterfaceField interface{}
 			}{}),
 			expected: pointer(
 				struct {
-					InnerField string
+					InnerField     string
+					InterfaceField interface{}
 				}{
-					InnerField: "inner",
+					InnerField:     "inner",
+					InterfaceField: "interface{}",
 				}),
 		},
 		{
@@ -896,13 +902,85 @@ func TestConverter(t *testing.T) { //nolint:maintidx
 			to:          pointer(OuterStruct{}),
 			err:         "'' expected a map, got 'string'",
 		},
-		// unsupported.
 		{
-			description: "to interface (unsupported)",
+			description: "int to interface",
+			from:        42,
+			to:          pointer(any(nil)),
+			expected:    pointer(any(42)),
+		},
+		{
+			description: "string to interface",
 			from:        "str",
 			to:          pointer(any(nil)),
-			err:         ": unsupported type: interface",
+			expected:    pointer(any("str")),
+		},
+		{
+			description: "float to interface",
+			from:        42.42,
+			to:          pointer(any(nil)),
+			expected:    pointer(any(42.42)),
 		},
+		{
+			description: "map to interface",
+			from:        map[string]int{"key": 42, "keySensitive": 43},
+			to:          pointer(any(nil)),
+			expected:    pointer(any(map[string]int{"key": 42, "keySensitive": 43})),
+		},
+		{
+			description: "map to interface (with keyMap)", // Probably redundant.
+			opts: []convert.Option{
+				convert.WithKeyMapper(strings.ToLower),
+			},
+			from:     map[string]int{"key": 42, "keysensitive": 43},
+			to:       pointer(any(nil)),
+			expected: pointer(any(map[string]int{"key": 42, "keysensitive": 43})),
+		},
+		{
+			description: "packed KV and field to map[string]interface{}",
+			from: map[string]interface{}{
+				"key1": maps.KeyValue{
+					Key:   "key1",
+					Value: "value1",
+				},
+				"key2": "value2",
+			},
+			to: pointer(map[string]interface{}{}),
+			expected: pointer(map[string]interface{}{
+				"key1": "value1",
+				"key2": "value2",
+			}),
+		},
+		{
+			description: "packed KV and field to struct (with keyMap)",
+			opts: []convert.Option{
+				convert.WithKeyMapper(strings.ToLower),
+			},
+			from: map[string]interface{}{
+				"key1": maps.KeyValue{
+					Key:   "key1",
+					Value: "value1",
+				},
+				"key2": "value2",
+			},
+			to: pointer(struct {
+				Key1 interface{}
+				Key2 interface{}
+			}{}),
+			expected: pointer(struct {
+				Key1 interface{}
+				Key2 interface{}
+			}{
+				Key1: "value1",
+				Key2: "value2",
+			}),
+		},
+		{
+			description: "slice to interface",
+			from:        []int{1, 2, 3},
+			to:          pointer(any(nil)),
+			expected:    pointer(any([]int{1, 2, 3})),
+		},
+		// unsupported.
 		{
 			description: "to func (unsupported)",
 			from:        "str",
@@ -966,9 +1044,10 @@ func (e *Enum) UnmarshalText(text []byte) error {
 
 type (
 	OuterStruct struct {
-		Enum         Enum
-		OuterField   string
-		privateField string //nolint:unused
+		Enum           Enum
+		OuterField     string
+		privateField   string //nolint:unused
+		InterfaceField interface{}
 
 		InnerStruct `konf:",squash"`
 		Inner       *InnerStruct