Implement MapValue

Author: elgopher

defaults.go

@@ -10,3 +10,7 @@ func acceptAllFields(string, Element) bool {
 func noRename(_ string, e Element) string {
 	return e.Name()
 }
+
+func interfaceValue(_ string, e Element) interface{} {
+	return e.Interface()
+}

mapify.go

@@ -28,6 +28,7 @@ type MapValue func(path string, e Element) interface{}
 // Element represents either a map entry, field of a struct or unnamed element of a slice.
 type Element struct {
 	name string
+	reflect.Value
 }
 
 func (e Element) Name() string {
@@ -62,6 +63,10 @@ func (i Instance) newInstance() Instance {
 		i.Rename = noRename
 	}
 
+	if i.MapValue == nil {
+		i.MapValue = interfaceValue
+	}
+
 	return i
 }
 
@@ -79,12 +84,13 @@ func (i Instance) mapStruct(path string, reflectValue reflect.Value) map[string]
 
 		fieldName := field.Name
 		fieldPath := path + "." + fieldName
-		element := Element{name: fieldName}
+		value := reflectValue.Field(j)
+		element := Element{name: fieldName, Value: value}
 
 		if i.Filter(fieldPath, element) {
-			value := reflectValue.Field(j)
 			renamed := i.Rename(fieldPath, element)
-			result[renamed] = i.mapAny(fieldPath, value.Interface())
+			mappedValue := i.MapValue(fieldPath, Element{name: element.Name(), Value: value})
+			result[renamed] = i.mapAny(fieldPath, mappedValue)
 		}
 	}
 

mapify_test.go

@@ -397,6 +397,27 @@ func TestFilter(t *testing.T) {
 			},
 			v)
 	})
+
+	t.Run("should filter by value", func(t *testing.T) {
+		instance := mapify.Instance{
+			Filter: func(path string, e mapify.Element) bool {
+				return e.String() == "keep it"
+			},
+		}
+		// when
+		v := instance.MapAny(
+			struct{ Field1, Field2 string }{
+				Field1: "keep it",
+				Field2: "omit this",
+			},
+		)
+		// then
+		assert.Equal(t,
+			map[string]interface{}{
+				"Field1": "keep it",
+			},
+			v)
+	})
 }
 
 func TestRename(t *testing.T) {
@@ -420,3 +441,55 @@ func TestRename(t *testing.T) {
 			v)
 	})
 }
+
+func TestMapValue(t *testing.T) {
+	mappedValue := "str"
+
+	t.Run("should map struct field", func(t *testing.T) {
+		instance := mapify.Instance{
+			MapValue: func(path string, e mapify.Element) interface{} {
+				if e.Name() == "Field1" {
+					return mappedValue
+				}
+
+				return e.Interface()
+			},
+		}
+		s := struct{ Field1, Field2 int }{
+			Field1: 1, Field2: 2,
+		}
+		// when
+		v := instance.MapAny(s)
+		// then
+		assert.Equal(t,
+			map[string]interface{}{
+				"Field1": mappedValue,
+				"Field2": s.Field2,
+			},
+			v)
+	})
+
+	t.Run("should map struct field by path", func(t *testing.T) {
+		instance := mapify.Instance{
+			MapValue: func(path string, e mapify.Element) interface{} {
+				if path == ".Field1" {
+					return mappedValue
+				}
+
+				return e.Interface()
+			},
+		}
+		s := struct{ Field1, Field2 int }{
+			Field1: 1, Field2: 2,
+		}
+		// when
+		v := instance.MapAny(s)
+		// then
+		assert.Equal(t,
+			map[string]interface{}{
+				"Field1": mappedValue,
+				"Field2": s.Field2,
+			},
+			v)
+	})
+}