First pass implementation

Author: Ryan Moran

constants.go

@@ -0,0 +1,3 @@
+package jsonapi
+
+const ContentType = "application/vnd.api+json"

constants_test.go

@@ -0,0 +1,14 @@
+package jsonapi_test
+
+import (
+	"github.com/ryanmoran/jsonapi"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Constants", func() {
+	It("defines a content type", func() {
+		Expect(jsonapi.ContentType).To(Equal("application/vnd.api+json"))
+	})
+})

decodable.go

@@ -0,0 +1,6 @@
+package jsonapi
+
+type Decodable interface {
+	Type() string
+	SetPrimary(id string)
+}

decode_attributes.go

@@ -0,0 +1,54 @@
+package jsonapi
+
+import (
+	"encoding/json"
+	"reflect"
+)
+
+type DecodeAttributes struct {
+	d Decodable
+}
+
+func NewDecodeAttributes(d Decodable) DecodeAttributes {
+	return DecodeAttributes{d}
+}
+
+func (da DecodeAttributes) UnmarshalJSON(data []byte) error {
+	var attributes map[string]interface{}
+
+	err := json.Unmarshal(data, &attributes)
+	if err != nil {
+		panic(err)
+	}
+
+	dValue := reflect.ValueOf(da.d).Elem()
+	dType := reflect.TypeOf(da.d).Elem()
+
+	fieldMap := map[string]reflect.Value{}
+	for i := 0; i < dValue.NumField(); i++ {
+		fieldStruct := dType.Field(i)
+		fieldValue := dValue.Field(i)
+		tag, ok := fieldStruct.Tag.Lookup("jsonapi")
+		if !ok {
+			continue
+		}
+
+		fieldMap[tag] = fieldValue
+	}
+
+	for k, v := range attributes {
+		field, ok := fieldMap[k]
+		if !ok || !field.CanSet() {
+			continue
+		}
+
+		value := reflect.ValueOf(v)
+		if value.Kind() != field.Kind() {
+			panic("kinds don't match")
+		}
+
+		field.Set(value)
+	}
+
+	return nil
+}

decode_document.go

@@ -0,0 +1,26 @@
+package jsonapi
+
+import "encoding/json"
+
+type DecodeDocument struct {
+	d Decodable
+}
+
+func NewDecodeDocument(d Decodable) DecodeDocument {
+	return DecodeDocument{d}
+}
+
+func (dd DecodeDocument) UnmarshalJSON(data []byte) error {
+	document := struct {
+		Data DecodeResourceObject `json:"data"`
+	}{
+		Data: NewDecodeResourceObject(dd.d),
+	}
+
+	err := json.Unmarshal(data, &document)
+	if err != nil {
+		panic(err)
+	}
+
+	return nil
+}

decode_payload.go

@@ -0,0 +1,28 @@
+package jsonapi
+
+import (
+	"encoding/json"
+)
+
+type DecodePayload struct {
+	v interface{}
+}
+
+func NewDecodePayload(v interface{}) DecodePayload {
+	return DecodePayload{v}
+}
+
+func (dp DecodePayload) UnmarshalJSON(data []byte) error {
+	decodable, ok := dp.v.(Decodable)
+	if !ok {
+		panic("not decodable")
+	}
+
+	document := NewDecodeDocument(decodable)
+	err := json.Unmarshal(data, &document)
+	if err != nil {
+		panic(err)
+	}
+
+	return nil
+}

decode_relationships.go

@@ -0,0 +1,68 @@
+package jsonapi
+
+import (
+	"encoding/json"
+)
+
+type DecodeRelationships struct {
+	d Decodable
+}
+
+func NewDecodeRelationships(d Decodable) DecodeRelationships {
+	return DecodeRelationships{d}
+}
+
+func (dr DecodeRelationships) UnmarshalJSON(data []byte) error {
+	assignable, ok := dr.d.(RelationshipsAssignable)
+	if !ok {
+		return nil
+	}
+
+	var relationshipsMap map[string]interface{}
+
+	err := json.Unmarshal(data, &relationshipsMap)
+	if err != nil {
+		panic(err)
+	}
+
+	var relationships []Relationship
+	for name, resource := range relationshipsMap {
+		switch r := resource.(type) {
+		case map[string]interface{}:
+			rType, _ := r["type"].(string)
+			rID, _ := r["id"].(string)
+
+			relationships = append(relationships, Relationship{
+				Name: name,
+				Type: SingularRelationship,
+				Resource: DecodeResourceLinkage{
+					ResourceType: rType,
+					ID:           rID,
+				},
+			})
+		case []interface{}:
+			for _, item := range r {
+				s, ok := item.(map[string]interface{})
+				if !ok {
+					panic("not a map")
+				}
+
+				sType, _ := s["type"].(string)
+				sID, _ := s["id"].(string)
+
+				relationships = append(relationships, Relationship{
+					Name: name,
+					Type: MultiRelationship,
+					Resource: DecodeResourceLinkage{
+						ResourceType: sType,
+						ID:           sID,
+					},
+				})
+			}
+		}
+	}
+
+	assignable.AssignRelationships(relationships)
+
+	return nil
+}

decode_resource_linkage.go

@@ -0,0 +1,14 @@
+package jsonapi
+
+type DecodeResourceLinkage struct {
+	ResourceType string
+	ID           string
+}
+
+func (drl DecodeResourceLinkage) Type() string {
+	return drl.ResourceType
+}
+
+func (drl DecodeResourceLinkage) Primary() string {
+	return drl.ID
+}

decode_resource_object.go

@@ -0,0 +1,36 @@
+package jsonapi
+
+import "encoding/json"
+
+type DecodeResourceObject struct {
+	d Decodable
+}
+
+func NewDecodeResourceObject(d Decodable) DecodeResourceObject {
+	return DecodeResourceObject{d}
+}
+
+func (dro DecodeResourceObject) UnmarshalJSON(data []byte) error {
+	object := struct {
+		Type          string              `json:"type"`
+		ID            string              `json:"id"`
+		Attributes    DecodeAttributes    `json:"attributes"`
+		Relationships DecodeRelationships `json:"relationships"`
+	}{
+		Attributes:    NewDecodeAttributes(dro.d),
+		Relationships: NewDecodeRelationships(dro.d),
+	}
+
+	err := json.Unmarshal(data, &object)
+	if err != nil {
+		panic(err)
+	}
+
+	if dro.d.Type() != object.Type {
+		panic("types don't match")
+	}
+
+	dro.d.SetPrimary(object.ID)
+
+	return nil
+}

encodable.go

@@ -0,0 +1,15 @@
+package jsonapi
+
+type Encodable interface {
+	Type() string
+	Primary() string
+}
+
+func ToEncodable(v interface{}) (Encodable, error) {
+	m, ok := v.(Encodable)
+	if !ok {
+		panic("cannot encode")
+	}
+
+	return m, nil
+}

encode_attributes.go

@@ -0,0 +1,19 @@
+package jsonapi
+
+import "reflect"
+
+type EncodeAttributes map[string]interface{}
+
+func NewEncodeAttributes(m interface{}) EncodeAttributes {
+	mType := reflect.TypeOf(m)
+	mValue := reflect.ValueOf(m)
+
+	attributes := EncodeAttributes{}
+	for i := 0; i < mType.NumField(); i++ {
+		if name, ok := mType.Field(i).Tag.Lookup("jsonapi"); ok {
+			attributes[name] = mValue.Field(i).Interface()
+		}
+	}
+
+	return attributes
+}

encode_document.go

@@ -0,0 +1,47 @@
+package jsonapi
+
+import (
+	"encoding/json"
+	"reflect"
+)
+
+type EncodeDocument struct {
+	Data   json.Marshaler `json:"data,omitempty"`
+	Errors Errors         `json:"errors,omitempty"`
+}
+
+func NewSingularEncodeDocument(m interface{}) (EncodeDocument, error) {
+	encodable, err := ToEncodable(m)
+	if err != nil {
+		panic(err)
+	}
+
+	return EncodeDocument{
+		Data: NewEncodeResourceObject(encodable),
+	}, nil
+}
+
+func NewMultipleEncodeDocument(m interface{}) (EncodeDocument, error) {
+	var resourceObjects EncodeResourceObjects
+
+	value := reflect.ValueOf(m)
+	for i := 0; i < value.Len(); i++ {
+		elem := value.Index(i)
+		encodable, err := ToEncodable(elem.Interface())
+		if err != nil {
+			panic(err)
+		}
+
+		resourceObjects = append(resourceObjects, NewEncodeResourceObject(encodable))
+	}
+
+	return EncodeDocument{
+		Data: resourceObjects,
+	}, nil
+}
+
+func NewErrorsEncodeDocument(errors Errors) (EncodeDocument, error) {
+	return EncodeDocument{
+		Errors: errors,
+	}, nil
+}

encode_links.go

@@ -0,0 +1,17 @@
+package jsonapi
+
+type EncodeLinks map[string]Link
+
+func NewEncodeLinks(m interface{}) EncodeLinks {
+	linkable, ok := m.(Linkable)
+	if !ok {
+		return nil
+	}
+
+	links := EncodeLinks{}
+	for _, link := range linkable.Links() {
+		links[link.Name] = link
+	}
+
+	return links
+}