Merge pull request #4 from Quanare/support-nested-structs

Support nested structs (#1)

Author: Kangaroux

.gitignore

@@ -0,0 +1,2 @@
+.idea
+vendor

README.md

@@ -45,9 +45,16 @@ Suppose we have a `Person` model
 
 ```go
 type Person struct {
-    FirstName string `json:"first_name"`
-    LastName  string `json:"last_name"`
-    Age       int    `json:"age"`
+    FirstName string  `json:"first_name"`
+    LastName  string  `json:"last_name"`
+    Age       int     `json:"age"`
+    Address   Address `json:"address"`
+}
+
+type Address struct {
+    Country     string `json:"country"`
+    City        string `json:"city"`
+    AddressLine string `json:"address_line"`
 }
 ```
 
@@ -56,7 +63,11 @@ and a client comes along and makes a `POST` request with this JSON.
 ```json
 {
     "first_name": "Jessie",
-    "age": "26"
+    "age": "26",
+    "address": {
+      "country": "Example country",
+      "city": "Example city"
+    }
 }
 ```
 
@@ -75,7 +86,7 @@ After comparing we now have a `CompareResults` instance stored in `results`.
 ```go
 type CompareResults struct {
 	MismatchedFields []FieldMismatch
-	MissingFields    []string
+	MissingFields    []FieldMissing
 }
 ```
 
@@ -93,18 +104,31 @@ import (
     schema "github.com/Kangaroux/go-map-schema"
 )
 
+// Person is the model we are using.
 type Person struct {
-    FirstName string `json:"first_name"`
-    LastName  string `json:"last_name"`
-    Age       int    `json:"age"`
+  FirstName string  `json:"first_name"`
+  LastName  string  `json:"last_name"`
+  Age       int     `json:"age"`
+  Address   Address `json:"address"`
+}
+
+// Address is the model we are using as nested for Person.
+type Address struct {
+  Country     string `json:"country"`
+  City        string `json:"city"`
+  AddressLine string `json:"address_line"`
 }
 
 func main() {
     // The JSON payload (src).
     payload := `{
-        "first_name": "Jessie",
-        "age": "26"
-    }`
+		"first_name": "Jessie",
+		"age": "26",
+		"address": {
+			"country": "Example country",
+			"city": "Example city"
+		}
+	}`
     m := make(map[string]interface{})
     json.Unmarshal([]byte(payload), &m)
 
@@ -120,7 +144,7 @@ func main() {
 ### Output
 
 ```
-missing fields:    [last_name]
+missing fields:    [last_name address.address_line]
 mismatched fields: [expected "age" to be a int but it's a string]
 ```
 

examples/required-fields/main.go

@@ -49,7 +49,7 @@ func main() {
 		m := make(map[string]string)
 
 		for _, f := range r.MissingFields {
-			m[f] = "this field is required"
+			m[f.String()] = "this field is required"
 		}
 
 		resp.OK = false

examples/type-errors/main.go

@@ -9,9 +9,17 @@ import (
 
 // Person is the model we are using.
 type Person struct {
-	FirstName string `json:"first_name"`
-	LastName  string `json:"last_name"`
-	Age       int    `json:"age"`
+	FirstName string  `json:"first_name"`
+	LastName  string  `json:"last_name"`
+	Age       int     `json:"age"`
+	Address   Address `json:"address"`
+}
+
+// Address is the model we are using as nested for Person.
+type Address struct {
+	Country     string `json:"country"`
+	City        string `json:"city"`
+	AddressLine string `json:"address_line"`
 }
 
 // Response is used to generate a JSON response.
@@ -23,7 +31,11 @@ type Response struct {
 func main() {
 	input := `{
 		"first_name": "Jessie",
-		"age": "26"
+		"age": "26",
+		"address": {
+			"country": "Example country",
+			"city": "Example city"
+		}
 	}`
 	m := make(map[string]interface{})
 	p := Person{}

lang.go

@@ -74,3 +74,14 @@ func TypeNameWithArticle(t string) string {
 		return "a " + t
 	}
 }
+
+// FieldNameWithPath returns the field name including the path in the following format: parent1.parent2.name
+func FieldNameWithPath(f string, path []string) string {
+	b := strings.Builder{}
+	for _, p := range path {
+		b.WriteString(p + ".")
+	}
+	b.WriteString(f)
+
+	return b.String()
+}

lang_test.go

@@ -184,3 +184,38 @@ func TestTypeNameWithArticle(t *testing.T) {
 		require.Equal(t, test.expected, actual)
 	}
 }
+
+// Tests that FieldNameWithPath returns the expected result.
+func TestFieldNameWithPath(t *testing.T) {
+
+	tests := []struct {
+		name     string
+		path     []string
+		expected string
+	}{
+		{
+			name:     "user",
+			expected: "user",
+		},
+		{
+			name:     "cat",
+			path:     []string{},
+			expected: "cat",
+		},
+		{
+			name:     "email",
+			path:     []string{"user"},
+			expected: "user.email",
+		},
+		{
+			name:     "is_primary",
+			path:     []string{"user", "contacts", "email"},
+			expected: "user.contacts.email.is_primary",
+		},
+	}
+
+	for _, test := range tests {
+		actual := schema.FieldNameWithPath(test.name, test.path)
+		require.Equal(t, test.expected, actual)
+	}
+}

schema.go

@@ -13,7 +13,7 @@ type CompareResults struct {
 	MismatchedFields []FieldMismatch
 
 	// MissingFields is a list of JSON field names which were not in src.
-	MissingFields []string
+	MissingFields []FieldMissing
 }
 
 // Errors returns a MismatchError containing the type errors. If there were no
@@ -32,6 +32,20 @@ func (cr *CompareResults) Errors() error {
 	return MismatchError(m)
 }
 
+type FieldMissing struct {
+	// Field is the JSON name of the field.
+	Field string
+
+	// Path is the full path to the field.
+	Path []string
+}
+
+// String returns the field name with its path.
+// e.g: "Cat.Foo"
+func (f FieldMissing) String() string {
+	return FieldNameWithPath(f.Field, f.Path)
+}
+
 // FieldMismatch represents a type mismatch between a struct field and a map field.
 type FieldMismatch struct {
 	// Field is the JSON name of the field.
@@ -42,6 +56,9 @@ type FieldMismatch struct {
 
 	// Actual is the actual type (type of the src field).
 	Actual string
+
+	// Path is the full path to the field.
+	Path []string
 }
 
 // Message returns the field mismatch error as a string.
@@ -55,12 +72,12 @@ func (f FieldMismatch) Message() string {
 }
 
 // Message returns the field mismatch error as a string, and includes the field name
-// in the message.
-// e.g: "expected Foo to be an int but it's a string"
+// with its path in the message.
+// e.g: "expected Cat.Foo to be an int but it's a string"
 func (f FieldMismatch) MessageWithField() string {
 	return fmt.Sprintf(
 		`expected "%s" to be %s but it's %s`,
-		f.Field,
+		FieldNameWithPath(f.Field, f.Path),
 		TypeNameWithArticle(f.Expected),
 		TypeNameWithArticle(f.Actual),
 	)
@@ -146,7 +163,7 @@ func CompareMapToStruct(dst interface{}, src map[string]interface{}, opts *Compa
 
 	results := &CompareResults{
 		MismatchedFields: []FieldMismatch{},
-		MissingFields:    []string{},
+		MissingFields:    []FieldMissing{},
 	}
 
 	compare(v.Elem().Type(), src, opts, results)
@@ -160,6 +177,7 @@ func CompareMapToStruct(dst interface{}, src map[string]interface{}, opts *Compa
 // t points to.
 func DefaultCanConvert(t reflect.Type, v reflect.Value) bool {
 	isPtr := t.Kind() == reflect.Ptr
+	isStruct := t.Kind() == reflect.Struct
 	dstType := t
 
 	// Check if v is a nil value.
@@ -170,6 +188,12 @@ func DefaultCanConvert(t reflect.Type, v reflect.Value) bool {
 	// If the dst is a pointer, check if we can convert to the type it's pointing to.
 	if isPtr {
 		dstType = t.Elem()
+		isStruct = t.Elem().Kind() == reflect.Struct
+	}
+
+	// If the dst is a struct, we should check its nested fields.
+	if isStruct {
+		return v.Kind() == reflect.Map
 	}
 
 	if !v.Type().ConvertibleTo(dstType) {
@@ -212,6 +236,9 @@ func compare(t reflect.Type, src map[string]interface{}, opts *CompareOpts, resu
 			continue
 		}
 
+		// If the field is a nested struct also check its fields.
+		shouldCheckNested := isStructType(f.Type)
+
 		if srcField, ok := src[fieldName]; ok {
 			srcValue := reflect.ValueOf(srcField)
 
@@ -231,9 +258,47 @@ func compare(t reflect.Type, src map[string]interface{}, opts *CompareOpts, resu
 				}
 
 				results.MismatchedFields = append(results.MismatchedFields, mismatch)
+				// There is no point to check nested fields if their parent is mismatched.
+				shouldCheckNested = false
 			}
 		} else {
-			results.MissingFields = append(results.MissingFields, fieldName)
+			missing := FieldMissing{Field: fieldName}
+
+			results.MissingFields = append(results.MissingFields, missing)
+			// There is no point to check nested fields if their parent is missing.
+			shouldCheckNested = false
+		}
+
+		if shouldCheckNested {
+			nested := src[fieldName].(map[string]interface{})
+			nestedType := f.Type
+			if f.Type.Kind() == reflect.Ptr {
+				nestedType = nestedType.Elem()
+			}
+
+			checkNestedFields(nestedType, fieldName, nested, opts, results)
+		}
+	}
+}
+
+func checkNestedFields(t reflect.Type, fieldName string, src map[string]interface{}, opts *CompareOpts, results *CompareResults) {
+	// Remember count of fields to check if new errors occured.
+	mismatchCount := len(results.MismatchedFields)
+	missingCount := len(results.MissingFields)
+
+	compare(t, src, opts, results)
+
+	// If there were new mismatched fields, add the current field name to their path.
+	if mismatchCount != len(results.MismatchedFields) {
+		for mi := mismatchCount; mi < len(results.MismatchedFields); mi++ {
+			results.MismatchedFields[mi].Path = append([]string{fieldName}, results.MismatchedFields[mi].Path...)
+		}
+	}
+
+	// If there were new missing fields, add the current field name to their path.
+	if missingCount != len(results.MissingFields) {
+		for mi := missingCount; mi < len(results.MissingFields); mi++ {
+			results.MissingFields[mi].Path = append([]string{fieldName}, results.MissingFields[mi].Path...)
 		}
 	}
 }
@@ -262,6 +327,17 @@ func isIntegerType(t reflect.Type) (yes bool, unsigned bool) {
 	return
 }
 
+// isStructType returns whether the type is a struct or a pointer to it.
+func isStructType(t reflect.Type) (yes bool) {
+	switch t.Kind() {
+	case reflect.Struct:
+		yes = true
+	case reflect.Ptr:
+		yes = t.Elem().Kind() == reflect.Struct
+	}
+	return
+}
+
 // parseField returns the field's JSON name.
 func parseField(f reflect.StructField) (name string, ignore bool) {
 	tag := f.Tag.Get("json")