Merge pull request #168 from manyminds/bugfix-unmarshaler-interface

Bugfix unmarshaler interface

Author: sharpner

jsonapi/marshal_enum_test.go

@@ -0,0 +1,125 @@
+package jsonapi
+
+import (
+	"encoding/json"
+	"fmt"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+type PublishStatus int
+
+const (
+	StatusUnpublished PublishStatus = iota
+	StatusPublished
+)
+
+var publishStatusValues = []string{
+	StatusUnpublished: "unpublished",
+	StatusPublished:   "published",
+}
+
+func (s PublishStatus) String() string {
+	if s < 0 || int(s) >= len(publishStatusValues) {
+		panic("value out of range")
+	}
+	return publishStatusValues[s]
+}
+
+// MarshalText implements the TextMarshaler interface.
+func (s PublishStatus) MarshalText() (text []byte, err error) {
+	return []byte(s.String()), nil
+}
+
+// UnmarshalText implements the TextUnmarshaler interface.
+func (s *PublishStatus) UnmarshalText(text []byte) error {
+	label := string(text)
+
+	for key, v := range publishStatusValues {
+		if v == label {
+			*s = PublishStatus(key)
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid value `%s`", label)
+}
+
+func (s *PublishStatus) UnmarshalJSON(data []byte) error {
+	var text string
+	if err := json.Unmarshal(data, &text); err != nil {
+		return err
+	}
+	return s.UnmarshalText([]byte(text))
+}
+
+type EnumPost struct {
+	ID     string `json:"-"`
+	Title  string
+	Status PublishStatus
+}
+
+func (e EnumPost) GetID() string {
+	return e.ID
+}
+
+func (e *EnumPost) SetID(ID string) error {
+	e.ID = ID
+
+	return nil
+}
+
+var _ = Describe("Custom enum types", func() {
+	status := StatusPublished
+	statusValue := "published"
+	singleJSON := []byte(`{"data":{"id": "1", "type": "enumPosts", "attributes": {"title":"First Post","status":"published"}}}`)
+	firstPost := EnumPost{ID: "1", Title: "First Post", Status: StatusPublished}
+	singlePostMap := map[string]interface{}{
+		"data": map[string]interface{}{
+			"id":   "1",
+			"type": "enumPosts",
+			"attributes": map[string]interface{}{
+				"title":  firstPost.Title,
+				"status": StatusPublished,
+			},
+		},
+	}
+
+	Context("When marshaling objects including enumes", func() {
+		singlePost := EnumPost{
+			ID:     "1",
+			Title:  "First Post",
+			Status: StatusPublished,
+		}
+
+		It("marshals JSON", func() {
+			result, err := MarshalToJSON(singlePost)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(result).To(MatchJSON(singleJSON))
+		})
+	})
+
+	Context("When unmarshaling objects including enums", func() {
+
+		It("unmarshals status string values to int enum type", func() {
+			var result PublishStatus
+			result.UnmarshalText([]byte(statusValue))
+			Expect(result).To(Equal(status))
+		})
+
+		It("unmarshals single objects into a struct", func() {
+			var post EnumPost
+			err := Unmarshal(singlePostMap, &post)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(post).To(Equal(firstPost))
+		})
+
+		It("unmarshals JSON", func() {
+			var posts []EnumPost
+			err := UnmarshalFromJSON(singleJSON, &posts)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(posts).To(Equal([]EnumPost{firstPost}))
+		})
+	})
+})

jsonapi/unmarshal.go

@@ -329,44 +329,44 @@ func setFieldValue(field *reflect.Value, value reflect.Value) (err error) {
 		}
 	}()
 
-	switch field.Type().Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		field.SetInt(int64(value.Float()))
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		field.SetUint(uint64(value.Float()))
-	case reflect.Slice:
-		// we always get a []interface{] from json and now need to cast to the right slice type
-		if value.Type() == reflect.TypeOf([]interface{}{}) {
-			targetSlice := reflect.MakeSlice(field.Type(), 0, value.Len())
-			sliceData := value.Interface().([]interface{})
-
-			// only iterate over the array if it's not empty
-			if value.Len() > 0 {
-				targetType := reflect.TypeOf(sliceData[0])
-				for _, entry := range sliceData {
-					casted := reflect.ValueOf(entry).Convert(targetType)
-					targetSlice = reflect.Append(targetSlice, casted)
-				}
-			}
+	// check for Unmarshaler interface first, after that try to guess the right type
+	target, ok := field.Addr().Interface().(json.Unmarshaler)
+	if ok {
+		marshaledValue, err := json.Marshal(value.Interface())
+		if err != nil {
+			return err
+		}
 
-			field.Set(targetSlice)
-		} else {
-			// we have the correct type, hm this is only for tests that use direct type at the moment.. we have to refactor the unmarshalling
-			// anyways..
-			field.Set(value)
+		err = target.UnmarshalJSON(marshaledValue)
+		if err != nil {
+			return err
 		}
-	default:
-		// try to set it with json.Unmarshaler interface, if that does not work, set value directly
-		switch target := field.Addr().Interface().(type) {
-		case json.Unmarshaler:
-			marshaledValue, err := json.Marshal(value.Interface())
-			if err != nil {
-				return err
-			}
+	} else {
+		switch field.Type().Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			field.SetInt(int64(value.Float()))
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+			field.SetUint(uint64(value.Float()))
+		case reflect.Slice:
+			// we always get a []interface{] from json and now need to cast to the right slice type
+			if value.Type() == reflect.TypeOf([]interface{}{}) {
+				targetSlice := reflect.MakeSlice(field.Type(), 0, value.Len())
+				sliceData := value.Interface().([]interface{})
+
+				// only iterate over the array if it's not empty
+				if value.Len() > 0 {
+					targetType := reflect.TypeOf(sliceData[0])
+					for _, entry := range sliceData {
+						casted := reflect.ValueOf(entry).Convert(targetType)
+						targetSlice = reflect.Append(targetSlice, casted)
+					}
+				}
 
-			err = target.UnmarshalJSON(marshaledValue)
-			if err != nil {
-				return err
+				field.Set(targetSlice)
+			} else {
+				// we have the correct type, hm this is only for tests that use direct type at the moment.. we have to refactor the unmarshalling
+				// anyways..
+				field.Set(value)
 			}
 		default:
 			field.Set(value)