Add ShouldConvert

With this new function user can specify which structs, maps or slices are converted. For example, user can skip conversion of standard struct types (such as time.Time) or can skip conversion of all maps with string key. Sometimes this functionality can be used for performances reasons too - user can reduce the amount of time spend on conversion significantly by skipping unnecessary conversion.

Author: elgopher

README.md

@@ -18,6 +18,7 @@
   * **rename keys** during conversion
   * **omit keys** based on field name, value or tag etc.
   * **map elements** during conversion
+  * specify which structs should be converted to maps
 
 ## Installation
 

_examples/skip/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"time"
+
+	"github.com/elgopher/mapify"
+)
+
+// This example shows how to skip conversion of some objects
+func main() {
+	mapper := mapify.Mapper{
+		ShouldConvert: shouldConvert,
+	}
+
+	v := struct {
+		Time          time.Time // time.Time is a struct too
+		DontConvertMe struct{ Field string }
+	}{
+		Time:          time.Now(),
+		DontConvertMe: struct{ Field string }{Field: "v"},
+	}
+
+	value, err := mapper.MapAny(v)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(value)
+}
+
+func shouldConvert(path string, v reflect.Value) (bool, error) {
+	t := v.Type()
+
+	if t.PkgPath() == "time" && t.Name() == "Time" {
+		// time.Time struct will not be converted to map
+		return false, nil
+	}
+
+	if path == ".DontConvertMe" {
+		return false, nil
+	}
+
+	return true, nil
+}

defaults.go

@@ -3,6 +3,12 @@
 
 package mapify
 
+import "reflect"
+
+func convertAll(string, reflect.Value) (bool, error) {
+	return true, nil
+}
+
 func acceptAllFields(string, Element) (bool, error) {
 	return true, nil
 }

mapify.go

@@ -12,11 +12,15 @@ import (
 
 // Mapper represents instance of mapper
 type Mapper struct {
-	Filter   Filter
-	Rename   Rename
-	MapValue MapValue
+	ShouldConvert ShouldConvert
+	Filter        Filter
+	Rename        Rename
+	MapValue      MapValue
 }
 
+// ShouldConvert returns true when value should be converted to map. The value can be a struct, map[string]any or slice.
+type ShouldConvert func(path string, value reflect.Value) (bool, error)
+
 // Filter returns true when element should be included. If error is returned then the whole conversion is aborted
 // and wrapped error is returned from Mapper.MapAny method.
 type Filter func(path string, e Element) (bool, error)
@@ -62,11 +66,28 @@ func (i Mapper) mapAny(path string, v interface{}) (interface{}, error) {
 	reflectValue := reflect.ValueOf(v)
 
 	switch {
-	case reflectValue.Kind() == reflect.Ptr && reflectValue.Elem().Kind() == reflect.Struct:
-		return i.mapAny(path, reflectValue.Elem().Interface())
-	case reflectValue.Kind() == reflect.Struct:
+	case reflectValue.Kind() == reflect.Struct ||
+		(reflectValue.Kind() == reflect.Ptr && reflectValue.Elem().Kind() == reflect.Struct):
+		shouldConvert, err := i.ShouldConvert(path, reflectValue)
+		if err != nil {
+			return nil, fmt.Errorf("ShouldConvert failed: %w", err)
+		}
+
+		if !shouldConvert {
+			return reflectValue.Interface(), nil
+		}
+
 		return i.mapStruct(path, reflectValue)
 	case reflectValue.Kind() == reflect.Map && reflectValue.Type().Key().Kind() == reflect.String:
+		shouldConvert, err := i.ShouldConvert(path, reflectValue)
+		if err != nil {
+			return nil, fmt.Errorf("ShouldConvert failed: %w", err)
+		}
+
+		if !shouldConvert {
+			return reflectValue.Interface(), nil
+		}
+
 		return i.mapStringMap(path, reflectValue)
 	case reflectValue.Kind() == reflect.Slice:
 		return i.mapSlice(path, reflectValue)
@@ -76,6 +97,10 @@ func (i Mapper) mapAny(path string, v interface{}) (interface{}, error) {
 }
 
 func (i Mapper) newInstance() Mapper {
+	if i.ShouldConvert == nil {
+		i.ShouldConvert = convertAll
+	}
+
 	if i.Filter == nil {
 		i.Filter = acceptAllFields
 	}
@@ -94,6 +119,8 @@ func (i Mapper) newInstance() Mapper {
 func (i Mapper) mapStruct(path string, reflectValue reflect.Value) (map[string]interface{}, error) {
 	result := map[string]interface{}{}
 
+	reflectValue = dereference(reflectValue)
+
 	reflectType := reflectValue.Type()
 
 	for j := 0; j < reflectType.NumField(); j++ {
@@ -116,6 +143,14 @@ func (i Mapper) mapStruct(path string, reflectValue reflect.Value) (map[string]i
 	return result, nil
 }
 
+func dereference(value reflect.Value) reflect.Value {
+	for value.Kind() == reflect.Ptr {
+		value = value.Elem()
+	}
+
+	return value
+}
+
 func (i Mapper) mapStringMap(path string, reflectValue reflect.Value) (map[string]interface{}, error) {
 	result := map[string]interface{}{}
 
@@ -167,6 +202,15 @@ func (i Mapper) mapSlice(path string, reflectValue reflect.Value) (_ interface{}
 
 	switch kind {
 	case reflect.Struct:
+		shouldConvert, err := i.ShouldConvert(path, reflectValue)
+		if err != nil {
+			return nil, fmt.Errorf("ShouldConvert failed: %w", err)
+		}
+
+		if !shouldConvert {
+			return reflectValue.Interface(), nil
+		}
+
 		slice := make([]map[string]interface{}, reflectValue.Len())
 
 		for j := 0; j < reflectValue.Len(); j++ {
@@ -182,6 +226,15 @@ func (i Mapper) mapSlice(path string, reflectValue reflect.Value) (_ interface{}
 			return reflectValue.Interface(), nil
 		}
 
+		shouldConvert, err := i.ShouldConvert(path, reflectValue)
+		if err != nil {
+			return nil, fmt.Errorf("ShouldConvert failed: %w", err)
+		}
+
+		if !shouldConvert {
+			return reflectValue.Interface(), nil
+		}
+
 		slice := make([]map[string]interface{}, reflectValue.Len())
 
 		for j := 0; j < reflectValue.Len(); j++ {
@@ -198,6 +251,15 @@ func (i Mapper) mapSlice(path string, reflectValue reflect.Value) (_ interface{}
 		if sliceElem.Kind() == reflect.Struct ||
 			(sliceElem.Kind() == reflect.Map && sliceElem.Key().Kind() == reflect.String) {
 
+			shouldConvert, err := i.ShouldConvert(path, reflectValue)
+			if err != nil {
+				return nil, fmt.Errorf("ShouldConvert failed: %w", err)
+			}
+
+			if !shouldConvert {
+				return reflectValue.Interface(), nil
+			}
+
 			var slice [][]map[string]interface{}
 
 			for j := 0; j < reflectValue.Len(); j++ {

mapify_test.go

@@ -4,6 +4,8 @@
 package mapify_test
 
 import (
+	"fmt"
+	"reflect"
 	"testing"
 
 	"github.com/elgopher/mapify"
@@ -700,3 +702,138 @@ func assertStructField(t *testing.T, fieldName string, e mapify.Element) {
 	require.True(t, ok)
 	assert.Equal(t, fieldName, field.Name)
 }
+
+func TestShouldConvert(t *testing.T) {
+	t.Run("should not convert root element", func(t *testing.T) {
+		mapper := mapify.Mapper{
+			ShouldConvert: func(path string, value reflect.Value) (bool, error) {
+				if path == "" {
+					return false, nil
+				}
+
+				return true, nil
+			},
+		}
+
+		tests := map[string]interface{}{
+			"struct": struct{ Field string }{Field: "v"},
+			"map":    map[string]string{"key": "value"},
+			"slice":  []struct{ Field string }{{Field: "v"}},
+		}
+
+		for name, instance := range tests {
+			t.Run(name, func(t *testing.T) {
+				// when
+				mapped, err := mapper.MapAny(instance)
+				// then
+				require.NoError(t, err)
+				assert.Equal(t, instance, mapped)
+			})
+		}
+	})
+
+	t.Run("should not convert nested object", func(t *testing.T) {
+		type nestedStruct struct{ Field string }
+
+		nestedStructInstance := nestedStruct{Field: "a"}
+		nestedMap := map[string]string{"Field": "a"}
+
+		tests := map[string]struct {
+			input, expected interface{}
+		}{
+			"struct in a struct field": {
+				input:    struct{ Nested nestedStruct }{Nested: nestedStructInstance},
+				expected: map[string]interface{}{"Nested": nestedStructInstance},
+			},
+			"struct pointer in a struct field": {
+				input:    struct{ Nested *nestedStruct }{Nested: &nestedStructInstance},
+				expected: map[string]interface{}{"Nested": &nestedStructInstance},
+			},
+			"struct in a map key": {
+				input:    map[string]nestedStruct{"Nested": nestedStructInstance},
+				expected: map[string]interface{}{"Nested": nestedStructInstance},
+			},
+			"map in a struct field": {
+				input:    struct{ Nested map[string]string }{Nested: nestedMap},
+				expected: map[string]interface{}{"Nested": nestedMap},
+			},
+			"map in a map key": {
+				input:    map[string]map[string]string{"Nested": nestedMap},
+				expected: map[string]interface{}{"Nested": nestedMap},
+			},
+			"structs slice in a struct field": {
+				input:    struct{ Nested []nestedStruct }{Nested: []nestedStruct{nestedStructInstance}},
+				expected: map[string]interface{}{"Nested": []nestedStruct{nestedStructInstance}},
+			},
+			"structs slice in a map key": {
+				input:    map[string][]nestedStruct{"Nested": {nestedStructInstance}},
+				expected: map[string]interface{}{"Nested": []nestedStruct{nestedStructInstance}},
+			},
+			"map slice in a struct field": {
+				input:    struct{ Nested []map[string]string }{Nested: []map[string]string{nestedMap}},
+				expected: map[string]interface{}{"Nested": []map[string]string{nestedMap}},
+			},
+			"2d structs slice in a map key": {
+				input:    map[string][][]nestedStruct{"Nested": {{nestedStructInstance}}},
+				expected: map[string]interface{}{"Nested": [][]nestedStruct{{nestedStructInstance}}},
+			},
+		}
+
+		mapper := mapify.Mapper{
+			ShouldConvert: func(path string, value reflect.Value) (bool, error) {
+				if path == ".Nested" {
+					return false, nil
+				}
+
+				return true, nil
+			},
+		}
+
+		for name, test := range tests {
+			t.Run(name, func(t *testing.T) {
+				// when
+				mapped, err := mapper.MapAny(test.input)
+				// then
+				require.NoError(t, err)
+				assert.Equal(t, test.expected, mapped)
+			})
+		}
+	})
+
+	t.Run("should not run ShouldConvert for inconvertible values", func(t *testing.T) {
+		mapper := mapify.Mapper{
+			ShouldConvert: func(path string, value reflect.Value) (bool, error) {
+				panic("ShouldConvert run but should not")
+			},
+		}
+
+		tests := []interface{}{nil, 1, "str", map[int]interface{}{}, []int{1}}
+
+		for _, test := range tests {
+			name := fmt.Sprintf("%+v", test)
+
+			t.Run(name, func(t *testing.T) {
+				assert.NotPanics(t, func() {
+					_, _ = mapper.MapAny(test)
+				})
+			})
+		}
+	})
+
+	t.Run("should run ShouldConvert only once for pointer to struct", func(t *testing.T) {
+		s := &struct{ Field string }{Field: "v"}
+
+		timesRun := 0
+		mapper := mapify.Mapper{
+			ShouldConvert: func(path string, value reflect.Value) (bool, error) {
+				assert.Equal(t, s, value.Interface())
+				timesRun++
+				return true, nil
+			},
+		}
+
+		_, err := mapper.MapAny(s)
+		require.NoError(t, err)
+		assert.Equal(t, 1, timesRun, "ShouldConvert must be executed only once")
+	})
+}