wip on #21 basic serialization. todo, deserialize embedded

Author: Sam Woodard

node.go

@@ -20,6 +20,35 @@ type Node struct {
 	Relationships map[string]interface{} `json:"relationships,omitempty"`
 }
 
+// Extend applies the attirbutes on the rhs to the callee
+func (n *Node) Extend(node *Node) {
+	for attr, val := range node.Attributes {
+		n.AddAttriute(attr, val)
+	}
+
+	for rel, val := range node.Relationships {
+		n.AddRelationship(rel, val)
+	}
+}
+
+// AddRelationship adds a relationship to the Node
+func (n *Node) AddRelationship(name string, val interface{}) {
+	if n.Relationships == nil {
+		n.Relationships = make(map[string]interface{})
+	}
+
+	n.Relationships[name] = val
+}
+
+// AddAttriute adds an attribute to the Node
+func (n *Node) AddAttriute(name string, val interface{}) {
+	if n.Attributes == nil {
+		n.Attributes = make(map[string]interface{})
+	}
+
+	n.Attributes[name] = val
+}
+
 type RelationshipOneNode struct {
 	Data  *Node              `json:"data"`
 	Links *map[string]string `json:"links,omitempty"`

response.go

@@ -42,7 +42,7 @@ func MarshalOnePayload(w io.Writer, model interface{}) error {
 func MarshalOne(model interface{}) (*OnePayload, error) {
 	included := make(map[string]*Node)
 
-	rootNode, err := visitModelNode(model, &included, true)
+	rootNode, err := visitModelNode(reflect.ValueOf(model), &included, true)
 	if err != nil {
 		return nil, err
 	}
@@ -99,7 +99,7 @@ func MarshalMany(models []interface{}) (*ManyPayload, error) {
 	for i := 0; i < len(models); i++ {
 		model := models[i]
 
-		node, err := visitModelNode(model, &included, true)
+		node, err := visitModelNode(reflect.ValueOf(model), &included, true)
 		if err != nil {
 			return nil, err
 		}
@@ -131,7 +131,7 @@ func MarshalMany(models []interface{}) (*ManyPayload, error) {
 //
 // model interface{} should be a pointer to a struct.
 func MarshalOnePayloadEmbedded(w io.Writer, model interface{}) error {
-	rootNode, err := visitModelNode(model, nil, false)
+	rootNode, err := visitModelNode(reflect.ValueOf(model), nil, false)
 	if err != nil {
 		return err
 	}
@@ -145,15 +145,28 @@ func MarshalOnePayloadEmbedded(w io.Writer, model interface{}) error {
 	return nil
 }
 
-func visitModelNode(model interface{}, included *map[string]*Node, sideload bool) (*Node, error) {
+func visitModelNode(model reflect.Value, included *map[string]*Node, sideload bool) (*Node, error) {
 	node := new(Node)
 
 	var er error
 
-	modelValue := reflect.ValueOf(model).Elem()
+	modelValue := model.Elem()
 
 	for i := 0; i < modelValue.NumField(); i++ {
 		structField := modelValue.Type().Field(i)
+
+		if structField.Anonymous {
+			if modelValue.Field(i).IsNil() {
+				continue
+			}
+			if n, err := visitModelNode(modelValue.Field(i), included, sideload); err == nil {
+				node.Extend(n)
+			} else {
+				err = err
+				break
+			}
+		}
+
 		tag := structField.Tag.Get("jsonapi")
 		if tag == "" {
 			continue
@@ -252,10 +265,6 @@ func visitModelNode(model interface{}, included *map[string]*Node, sideload bool
 				continue
 			}
 
-			if node.Relationships == nil {
-				node.Relationships = make(map[string]interface{})
-			}
-
 			if isSlice {
 				relationship, err := visitModelNodeRelationships(args[1], fieldValue, included, sideload)
 
@@ -269,22 +278,22 @@ func visitModelNode(model interface{}, included *map[string]*Node, sideload bool
 							shallowNodes = append(shallowNodes, toShallowNode(n))
 						}
 
-						node.Relationships[args[1]] = &RelationshipManyNode{Data: shallowNodes}
+						node.AddRelationship(args[1], &RelationshipManyNode{Data: shallowNodes})
 					} else {
-						node.Relationships[args[1]] = relationship
+						node.AddRelationship(args[1], relationship)
 					}
 				} else {
 					er = err
 					break
 				}
 			} else {
-				relationship, err := visitModelNode(fieldValue.Interface(), included, sideload)
+				relationship, err := visitModelNode(fieldValue, included, sideload)
 				if err == nil {
 					if sideload {
 						appendIncluded(included, relationship)
-						node.Relationships[args[1]] = &RelationshipOneNode{Data: toShallowNode(relationship)}
+						node.AddRelationship(args[1], &RelationshipOneNode{Data: toShallowNode(relationship)})
 					} else {
-						node.Relationships[args[1]] = &RelationshipOneNode{Data: relationship}
+						node.AddRelationship(args[1], &RelationshipOneNode{Data: relationship})
 					}
 				} else {
 					er = err
@@ -321,7 +330,7 @@ func visitModelNodeRelationships(relationName string, models reflect.Value, incl
 
 	for i := 0; i < models.Len(); i++ {
 		n := models.Index(i).Interface()
-		node, err := visitModelNode(n, included, sideload)
+		node, err := visitModelNode(reflect.ValueOf(n), included, sideload)
 		if err != nil {
 			return nil, err
 		}

response_test.go

@@ -3,6 +3,7 @@ package jsonapi
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"testing"
 	"time"
 )
@@ -19,7 +20,7 @@ type Blog struct {
 }
 
 type Post struct {
-	Blog
+	*Rating
 	Id            int        `jsonapi:"primary,posts"`
 	BlogId        int        `jsonapi:"attr,blog_id"`
 	ClientId      string     `jsonapi:"client-id"`
@@ -30,12 +31,48 @@ type Post struct {
 }
 
 type Comment struct {
+	*Rating
 	Id       int    `jsonapi:"primary,comments"`
 	ClientId string `jsonapi:"client-id"`
 	PostId   int    `jsonapi:"attr,post_id"`
 	Body     string `jsonapi:"attr,body"`
 }
 
+type Rating struct {
+	Score   int    `jsonapi:"attr,score"`
+	Comment string `jsonapi:"attr,comment"`
+}
+
+func TestEmbedded(t *testing.T) {
+	blog := testBlog()
+	buf := bytes.NewBuffer(nil)
+
+	if err := MarshalOnePayloadEmbedded(buf, blog); err != nil {
+		t.Fatal(err)
+	}
+
+	payload := new(OnePayload)
+	if err := json.NewDecoder(buf).Decode(payload); err != nil {
+		t.Fatal(err)
+	}
+
+	posts := payload.Data.Relationships["posts"].(map[string]interface{})["data"].([]interface{})
+	firstPostData := posts[0].(map[string]interface{})
+	firstPostAttrs := posts[0].(map[string]interface{})["attributes"].(map[string]interface{})
+
+	if val, exists := firstPostAttrs["score"]; !exists || val.(float64) != 5.0 {
+		t.Fatalf("Expected emedded score, 5, got %d", val)
+	}
+
+	expected := "Bad ass post!"
+	if val, exists := firstPostAttrs["comment"]; !exists || val.(string) != expected {
+		t.Fatalf("Expected emebedded rating comment to be, %s, was %s.", expected, val)
+	}
+}
+
+func TestEmbedded_nil(t *testing.T) {
+}
+
 func TestHasPrimaryAnnotation(t *testing.T) {
 	testModel := &Blog{
 		Id:        5,
@@ -243,6 +280,10 @@ func testBlog() *Blog {
 		CreatedAt: time.Now(),
 		Posts: []*Post{
 			&Post{
+				Rating: &Rating{
+					Score:   5,
+					Comment: "Bad ass post!",
+				},
 				Id:    1,
 				Title: "Foo",
 				Body:  "Bar",