Merge pull request #294 from russmatney/master

feat(encoding): allow for referential arrays

Author: dancannon

encoding/encoder_test.go

@@ -324,3 +324,26 @@ func TestReferenceFieldInvalid(t *testing.T) {
 		t.Errorf("expected non-nil error but got nil")
 	}
 }
+
+type RefE struct {
+	ID   string  `gorethink:"id,omitempty"`
+	FIDs *[]RefF `gorethink:"f_ids,reference" gorethink_ref:"id"`
+}
+
+type RefF struct {
+	ID   string `gorethink:"id,omitempty"`
+	Name string `gorethink:"name"`
+}
+
+func TestReferenceFieldArray(t *testing.T) {
+	input := RefE{"1", &[]RefF{RefF{"2", "Name2"}, RefF{"3", "Name3"}}}
+	want := map[string]interface{}{"id": "1", "f_ids": []string{"2", "3"}}
+
+	out, err := Encode(input)
+	if err != nil {
+		t.Errorf("got error %v, expected nil", err)
+	}
+	if !jsonEqual(out, want) {
+		t.Errorf("got %q, want %q", out, want)
+	}
+}

encoding/encoder_types.go

@@ -148,7 +148,6 @@ type structEncoder struct {
 
 func (se *structEncoder) encode(v reflect.Value) interface{} {
 	m := make(map[string]interface{})
-
 	for i, f := range se.fields {
 		fv := fieldByIndex(v, f.index)
 		if !fv.IsValid() || f.omitEmpty && se.isEmptyValue(fv) {
@@ -159,27 +158,8 @@ func (se *structEncoder) encode(v reflect.Value) interface{} {
 
 		// If this field is a referenced field then attempt to extract the value.
 		if f.reference {
-			refName := f.name
-			if f.refName != "" {
-				refName = f.refName
-			}
-
-			// referenced fields can only handle maps so return an error if the
-			// encoded field is of a different type
-			m, ok := encField.(map[string]interface{})
-			if !ok {
-				err := fmt.Errorf("Error referencing field %s in %s, expected object but got %t", refName, f.name, encField)
-				panic(&MarshalerError{v.Type(), err})
-			}
-
-			refVal, ok := m[refName]
-			if !ok {
-				err := fmt.Errorf("Error referencing field %s in %s, could not find referenced field", refName, f.name)
-				panic(&MarshalerError{v.Type(), err})
-			}
-
 			// Override the encoded field with the referenced field
-			encField = refVal
+			encField = getReferenceField(f, v, encField)
 		}
 
 		m[f.name] = encField
@@ -188,6 +168,40 @@ func (se *structEncoder) encode(v reflect.Value) interface{} {
 	return m
 }
 
+func getReferenceField(f field, v reflect.Value, encField interface{}) interface{} {
+	refName := f.name
+	if f.refName != "" {
+		refName = f.refName
+	}
+
+	encFields, isArray := encField.([]interface{})
+	if isArray {
+		refVals := make([]interface{}, len(encFields))
+		for i, e := range encFields {
+			refVals[i] = extractValue(e, v, f.name, refName)
+		}
+		return refVals
+	}
+	refVal := extractValue(encField, v, f.name, refName)
+	return refVal
+}
+
+func extractValue(encField interface{}, v reflect.Value, name string, refName string) interface{} {
+	// referenced fields can only handle maps so return an error if the
+	// encoded field is of a different type
+	m, ok := encField.(map[string]interface{})
+	if !ok {
+		err := fmt.Errorf("Error refing field %s in %s, expected object but got %t", refName, name, encField)
+		panic(&MarshalerError{v.Type(), err})
+	}
+	refVal, ok := m[refName]
+	if !ok {
+		err := fmt.Errorf("Error refing field %s in %s, could not find referenced field", refName, name)
+		panic(&MarshalerError{v.Type(), err})
+	}
+	return refVal
+}
+
 func (se *structEncoder) isEmptyValue(v reflect.Value) bool {
 	if v.Type() == timeType {
 		return v.Interface().(time.Time) == time.Time{}