Fill in embedded structs when unmarshaling

Closes #25

Author: oschwald

decoder.go

@@ -250,6 +250,17 @@ func (d *decoder) unmarshalMap(size uint, offset uint, result reflect.Value) (ui
 		newOffset, err := d.decodeMap(size, offset, rv)
 		result.Set(rv)
 		return newOffset, err
+	case reflect.Ptr:
+		// XXX - This duplicate Ptr hanlding code exists because decodeMap
+		// calls unmarshalMap directly when handling embeded structs. It
+		// would be nice to clean this up.
+		for result.Kind() == reflect.Ptr {
+			if result.IsNil() {
+				result.Set(reflect.New(result.Type().Elem()))
+			}
+			result = result.Elem()
+		}
+		return d.unmarshalMap(size, offset, result)
 	}
 }
 
@@ -450,8 +461,13 @@ func (d *decoder) decodeString(size uint, offset uint) (string, uint, error) {
 	return string(d.buffer[offset:newOffset]), newOffset, nil
 }
 
+type fieldsType struct {
+	namedFields     map[string]int
+	anonymousFields []int
+}
+
 var (
-	fieldMap   = map[reflect.Type]map[string]int{}
+	fieldMap   = map[reflect.Type]*fieldsType{}
 	fieldMapMu sync.RWMutex
 )
 
@@ -463,21 +479,39 @@ func (d *decoder) decodeStruct(size uint, offset uint, result reflect.Value) (ui
 	fieldMapMu.RUnlock()
 	if !ok {
 		numFields := resultType.NumField()
-		fields = make(map[string]int, numFields)
+		namedFields := make(map[string]int, numFields)
+		var anonymous []int
 		for i := 0; i < numFields; i++ {
-			fieldType := resultType.Field(i)
+			field := resultType.Field(i)
 
-			fieldName := fieldType.Name
-			if tag := fieldType.Tag.Get("maxminddb"); tag != "" {
+			fieldName := field.Name
+			if tag := field.Tag.Get("maxminddb"); tag != "" {
+				if tag == "-" {
+					continue
+				}
 				fieldName = tag
 			}
-			fields[fieldName] = i
+			if field.Anonymous {
+				anonymous = append(anonymous, i)
+				continue
+			}
+			namedFields[fieldName] = i
 		}
 		fieldMapMu.Lock()
+		fields = &fieldsType{namedFields, anonymous}
 		fieldMap[resultType] = fields
 		fieldMapMu.Unlock()
 	}
 
+	// This fills in embedded structs
+	for i := range fields.anonymousFields {
+		_, err := d.unmarshalMap(size, offset, result.Field(i))
+		if err != nil {
+			return 0, err
+		}
+	}
+
+	// This handles named fields
 	for i := uint(0); i < size; i++ {
 		var (
 			err error
@@ -487,12 +521,13 @@ func (d *decoder) decodeStruct(size uint, offset uint, result reflect.Value) (ui
 		if err != nil {
 			return 0, err
 		}
-		i, ok := fields[key]
+		j, ok := fields.namedFields[key]
 		if !ok {
 			offset = d.nextValueOffset(offset, 1)
 			continue
 		}
-		offset, err = d.decode(offset, result.Field(i))
+
+		offset, err = d.decode(offset, result.Field(j))
 		if err != nil {
 			return 0, err
 		}

reader_test.go

@@ -162,8 +162,19 @@ func (s *MySuite) TestDecoder(c *C) {
 	c.Assert(reader.Close(), IsNil)
 }
 
+type NestedMapX struct {
+	UTF8StringX string `maxminddb:"utf8_stringX"`
+}
+
+type NestedPointerMapX struct {
+	ArrayX []int `maxminddb:"arrayX"`
+}
+
 type PointerMap struct {
-	MapX map[string]interface{} `maxminddb:"mapX"`
+	MapX struct {
+		NestedMapX
+		*NestedPointerMapX
+	} `maxminddb:"mapX"`
 }
 
 type TestPointerType struct {
@@ -183,14 +194,13 @@ type TestPointerType struct {
 	Utf8String *string  `maxminddb:"utf8_string"`
 }
 
-func (s *MySuite) TestStructWithPointer(c *C) {
+func (s *MySuite) TestComplexStructWithNestingAndPointer(c *C) {
 	reader, err := Open("test-data/test-data/MaxMind-DB-test-decoder.mmdb")
 	c.Assert(err, IsNil)
 
 	var result TestPointerType
 
-	c.Log("Before")
-	reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
+	err = reader.Lookup(net.ParseIP("::1.1.1.0"), &result)
 	c.Assert(err, IsNil)
 
 	c.Assert(*result.Array, DeepEquals, []uint{uint(1), uint(2), uint(3)})
@@ -200,11 +210,9 @@ func (s *MySuite) TestStructWithPointer(c *C) {
 	c.Assert(*result.Float, Equals, float32(1.1))
 	c.Assert(*result.Int32, Equals, int32(-268435456))
 
-	c.Assert(result.Map.MapX, DeepEquals,
-		map[string]interface{}{
-			"arrayX":       []interface{}{uint64(7), uint64(8), uint64(9)},
-			"utf8_stringX": "hello",
-		})
+	c.Assert(result.Map.MapX.ArrayX, DeepEquals, []int{7, 8, 9})
+
+	c.Assert(result.Map.MapX.UTF8StringX, Equals, "hello")
 
 	c.Assert(*result.Uint16, Equals, uint16(100))
 	c.Assert(*result.Uint32, Equals, uint32(268435456))