decode: Only recursively unslice when the target is an interface{}
This commit is contained in:
parent
f613c919d2
commit
dad8f29d4e
|
@ -94,11 +94,13 @@ func canonicalFieldKey(field reflect.StructField) string {
|
|||
return parts[0]
|
||||
}
|
||||
|
||||
// HookWeakDecodeFromSlice looks for []map[string]interface{} in the source
|
||||
// data. If the target is not a slice or array it attempts to unpack 1 item
|
||||
// out of the slice. If there are more items the source data is left unmodified,
|
||||
// allowing mapstructure to handle and report the decode error caused by
|
||||
// mismatched types.
|
||||
// HookWeakDecodeFromSlice looks for []map[string]interface{} and []interface{}
|
||||
// in the source data. If the target is not a slice or array it attempts to unpack
|
||||
// 1 item out of the slice. If there are more items the source data is left
|
||||
// unmodified, allowing mapstructure to handle and report the decode error caused by
|
||||
// mismatched types. The []interface{} is handled so that all slice types are
|
||||
// behave the same way, and for the rare case when a raw structure is re-encoded
|
||||
// to JSON, which will produce the []interface{}.
|
||||
//
|
||||
// If this hook is being used on a "second pass" decode to decode an opaque
|
||||
// configuration into a type, the DecodeConfig should set WeaklyTypedInput=true,
|
||||
|
@ -122,18 +124,31 @@ func HookWeakDecodeFromSlice(from, to reflect.Type, data interface{}) (interface
|
|||
|
||||
switch d := data.(type) {
|
||||
case []map[string]interface{}:
|
||||
if len(d) == 1 {
|
||||
switch {
|
||||
case len(d) != 1:
|
||||
return data, nil
|
||||
case to == typeOfEmptyInterface:
|
||||
return unSlice(d[0])
|
||||
default:
|
||||
return d[0], nil
|
||||
}
|
||||
// the JSON decoder can apparently decode slices as []interface{}
|
||||
|
||||
// a slice map be encoded as []interface{} in some cases
|
||||
case []interface{}:
|
||||
if len(d) == 1 {
|
||||
switch {
|
||||
case len(d) != 1:
|
||||
return data, nil
|
||||
case to == typeOfEmptyInterface:
|
||||
return unSlice(d[0])
|
||||
default:
|
||||
return d[0], nil
|
||||
}
|
||||
}
|
||||
return data, nil
|
||||
}
|
||||
|
||||
var typeOfEmptyInterface = reflect.TypeOf((*interface{})(nil)).Elem()
|
||||
|
||||
func unSlice(data interface{}) (interface{}, error) {
|
||||
err := reflectwalk.Walk(data, &unSliceWalker{})
|
||||
return data, err
|
||||
|
@ -155,6 +170,11 @@ func (u *unSliceWalker) MapElem(m, k, v reflect.Value) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
m.SetMapIndex(k, v.Index(0))
|
||||
first := v.Index(0)
|
||||
// The value should always be assignable, but double check to avoid a panic.
|
||||
if !first.Type().AssignableTo(m.Type().Elem()) {
|
||||
return nil
|
||||
}
|
||||
m.SetMapIndex(k, first)
|
||||
return nil
|
||||
}
|
||||
|
|
|
@ -198,9 +198,11 @@ func TestTranslationsForType(t *testing.T) {
|
|||
}
|
||||
|
||||
type nested struct {
|
||||
O map[string]interface{}
|
||||
Slice []Item
|
||||
Item Item
|
||||
O map[string]interface{}
|
||||
Slice []Item
|
||||
Item Item
|
||||
OSlice []map[string]interface{}
|
||||
Sub *nested
|
||||
}
|
||||
|
||||
type Item struct {
|
||||
|
@ -215,6 +217,14 @@ slice {
|
|||
slice {
|
||||
name = "second"
|
||||
}
|
||||
item {
|
||||
name = "solo"
|
||||
}
|
||||
sub {
|
||||
oslice {
|
||||
something = "v1"
|
||||
}
|
||||
}
|
||||
`
|
||||
target := &nested{}
|
||||
err := decodeHCLToMapStructure(source, target)
|
||||
|
@ -222,6 +232,12 @@ slice {
|
|||
|
||||
expected := &nested{
|
||||
Slice: []Item{{Name: "first"}, {Name: "second"}},
|
||||
Item: Item{Name: "solo"},
|
||||
Sub: &nested{
|
||||
OSlice: []map[string]interface{}{
|
||||
{"something": "v1"},
|
||||
},
|
||||
},
|
||||
}
|
||||
require.Equal(t, target, expected)
|
||||
}
|
||||
|
@ -242,6 +258,40 @@ func decodeHCLToMapStructure(source string, target interface{}) error {
|
|||
return decoder.Decode(&raw)
|
||||
}
|
||||
|
||||
func TestHookWeakDecodeFromSlice_DoesNotModifySliceTargetsFromSliceInterface(t *testing.T) {
|
||||
raw := map[string]interface{}{
|
||||
"slice": []interface{}{map[string]interface{}{"name": "first"}},
|
||||
"item": []interface{}{map[string]interface{}{"name": "solo"}},
|
||||
"sub": []interface{}{
|
||||
map[string]interface{}{
|
||||
"OSlice": []interface{}{
|
||||
map[string]interface{}{"something": "v1"},
|
||||
},
|
||||
"item": []interface{}{map[string]interface{}{"name": "subitem"}},
|
||||
},
|
||||
},
|
||||
}
|
||||
target := &nested{}
|
||||
decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
|
||||
DecodeHook: HookWeakDecodeFromSlice,
|
||||
Result: target,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
err = decoder.Decode(&raw)
|
||||
|
||||
expected := &nested{
|
||||
Slice: []Item{{Name: "first"}},
|
||||
Item: Item{Name: "solo"},
|
||||
Sub: &nested{
|
||||
OSlice: []map[string]interface{}{
|
||||
{"something": "v1"},
|
||||
},
|
||||
Item: Item{Name: "subitem"},
|
||||
},
|
||||
}
|
||||
require.Equal(t, target, expected)
|
||||
}
|
||||
|
||||
func TestHookWeakDecodeFromSlice_ErrorsWithMultipleNestedBlocks(t *testing.T) {
|
||||
source := `
|
||||
item {
|
||||
|
|
Loading…
Reference in New Issue