Add support for embedded structs

Author: llamborda

decoder.go

@@ -175,6 +175,7 @@ func (d *decoder) readDictionary() (map[string]interface{}, error) {
   if _, err := d.reader.ReadByte(); err != nil {
     return nil, err
   }
+
 	var v interface{}
 	for {
 		s, _ := d.readString()
@@ -201,6 +202,7 @@ func (d *decoder) readDictionary() (map[string]interface{}, error) {
 		case reflect.Map:
 			v, err = d.readDictionary()
 		}
+
 		res[s] = v
 		if err != nil {
 			return res, err
@@ -238,8 +240,15 @@ func getStructFields(t reflect.Type) map[string]reflect.StructField {
 	r := make(map[string]reflect.StructField)
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
-		r[string(f.Tag.Get("bencode"))] = f
-	}
+    tag := string(f.Tag.Get("bencode"))
+    if len(tag) == 0 {
+      for et, ev := range getStructFields(f.Type) {
+        r[et] = ev
+      }
+      continue
+    }
+		r[tag] = f
+  }
 	return r
 }
 

decoder_test.go

@@ -1,7 +1,6 @@
 package bencode
 
 import (
-	"fmt"
 	"reflect"
 	"testing"
 )
@@ -75,8 +74,50 @@ func TestDecodeMockTorrentFile(t *testing.T) {
 		t.Error(err)
 	}
 	if !reflect.DeepEqual(have, want) {
-		fmt.Println(have.Info)
-		fmt.Println(want.Info)
 		t.Errorf("Struct not properly hidrated: wanted %+v but have %+v", want, have)
 	}
 }
+
+func TestDecodeEmbeddedStruct(t *testing.T) {
+	type base struct {
+    Basefield string `bencode:"base"`
+	}
+  type extended struct {
+    base
+    Extendedfield string `bencode:"extended"`
+  }
+  have := &extended{}
+  want := &extended{base{"base"}, "extended"}
+	input := []byte("d4:base4:base8:extended8:extendede")
+  err := Decode(input, have)
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(have, want) {
+		t.Errorf("Struct not properly encoded: wanted %s but have %s", want, have)
+	}
+}
+
+func TestDecodeDoubleEmbeddedStruct(t *testing.T) {
+	type base struct {
+    Basefield string `bencode:"base"`
+	}
+  type extended struct {
+    base
+    Extendedfield string `bencode:"extended"`
+  }
+  type doubleExtended struct {
+    extended
+    DoubleExtendedField string `bencode:"doubleExtended"`
+  }
+  have := &doubleExtended{}
+  want := &doubleExtended{extended{base{"base"}, "extended"}, "doubleExtended"}
+  input := []byte("d4:base4:base14:doubleExtended14:doubleExtended8:extended8:extendede")
+  err := Decode(input, have)
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(have, want) {
+		t.Errorf("Struct not properly encoded: wanted %s but have %s", want, have)
+	}
+}

encoder.go

@@ -43,26 +43,37 @@ func (e *encoder) encodeList(rv reflect.Value) {
 
 func (e *encoder) encodeDict(rv reflect.Value) error {
 	e.output.WriteByte('d')
+  e.traverseStruct(rv)
+	e.output.WriteByte('e')
+	return nil
+}
+
+func (e *encoder) traverseStruct(rv reflect.Value) error {
 	indirect := reflect.Indirect(rv)
 	for i := 0; i < indirect.NumField(); i++ {
+    key := indirect.Type().Field(i).Tag.Get("bencode")
 		switch indirect.Type().Field(i).Type.Kind() {
 		case reflect.Uint64:
-			e.encodeString(indirect.Type().Field(i).Tag.Get("bencode"))
+			e.encodeString(key)
 			e.encodeUint(indirect.Field(i).Interface().(uint64))
 		case reflect.String:
-			e.encodeString(indirect.Type().Field(i).Tag.Get("bencode"))
+			e.encodeString(key)
 			e.encodeString(indirect.Field(i).Interface().(string))
 		case reflect.Struct:
-			e.encodeString(indirect.Type().Field(i).Tag.Get("bencode"))
-      if err := e.encodeDict(indirect.Field(i).Addr()); err != nil {
+      str := indirect.Field(i).Addr()
+      if len(key) == 0 {
+        e.traverseStruct(str)
+        continue
+      }
+      e.encodeString(key)
+      if err := e.encodeDict(str); err != nil {
         return err
       }
 		case reflect.Slice:
-			e.encodeString(indirect.Type().Field(i).Tag.Get("bencode"))
+			e.encodeString(key)
 			e.encodeList(indirect.Field(i).Addr())
 		}
 	}
-	e.output.WriteByte('e')
 	return nil
 }
 

encoder_test.go

@@ -71,3 +71,44 @@ func TestEncodeMockTorrentFile(t *testing.T) {
 		t.Errorf("Struct not properly encoded: wanted %s but have %s", want, have)
 	}
 }
+
+func TestEncodeEmbeddedStruct(t *testing.T) {
+	type base struct {
+    Basefield string `bencode:"base"`
+	}
+  type extended struct {
+    base
+    Extendedfield string `bencode:"extended"`
+  }
+	have, err := Encode(&extended{base{"base"}, "extended"})
+	want := []byte("d4:base4:base8:extended8:extendede")
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(have, want) {
+		t.Errorf("Struct not properly encoded: wanted %s but have %s", want, have)
+	}
+}
+
+func TestEncodeDoubleEmbeddedStruct(t *testing.T) {
+	type base struct {
+    Basefield string `bencode:"base"`
+	}
+  type extended struct {
+    base
+    Extendedfield string `bencode:"extended"`
+  }
+  type doubleExtended struct {
+    extended
+    DoubleExtendedField string `bencode:"doubleExtended"`
+  }
+	have, err := Encode(&doubleExtended{extended{base{"base"}, "extended"}, "doubleExtended"})
+  want := []byte("d4:base4:base8:extended8:extended14:doubleExtended14:doubleExtendede")
+	if err != nil {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(have, want) {
+		t.Errorf("Struct not properly encoded: wanted %s but have %s", want, have)
+	}
+}
+