implement support for struct fields that implement json.Marshaler/Unmarshaler

Author: skimata

attributes.go

@@ -0,0 +1,69 @@
+package jsonapi
+
+import (
+	"encoding/json"
+	"reflect"
+	"strconv"
+	"time"
+)
+
+const iso8601Layout = "2006-01-02T15:04:05Z07:00"
+
+// ISO8601Datetime represents a ISO8601 formatted datetime
+// It is a time.Time instance that marshals and unmarshals to the ISO8601 ref
+type ISO8601Datetime struct {
+	time.Time
+}
+
+// MarshalJSON implements the json.Marshaler interface.
+func (t *ISO8601Datetime) MarshalJSON() ([]byte, error) {
+	s := t.Time.Format(iso8601Layout)
+	return json.Marshal(s)
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+func (t *ISO8601Datetime) UnmarshalJSON(data []byte) error {
+	// Ignore null, like in the main JSON package.
+	if string(data) == "null" {
+		return nil
+	}
+	// Fractional seconds are handled implicitly by Parse.
+	var err error
+	t.Time, err = time.Parse(strconv.Quote(iso8601Layout), string(data))
+	return err
+}
+
+// ISO8601Datetime.String() - override default String() on time
+func (t ISO8601Datetime) String() string {
+	return t.Format(iso8601Layout)
+}
+
+// func to help determine json.Marshaler implementation
+// checks both pointer and non-pointer implementations
+func isJSONMarshaler(fv reflect.Value) (json.Marshaler, bool) {
+	if u, ok := fv.Interface().(json.Marshaler); ok {
+		return u, ok
+	}
+
+	if !fv.CanAddr() {
+		return nil, false
+	}
+
+	u, ok := fv.Addr().Interface().(json.Marshaler)
+	return u, ok
+}
+
+// func to help determine json.Unmarshaler implementation
+// checks both pointer and non-pointer implementations
+func isJSONUnmarshaler(fv reflect.Value) (json.Unmarshaler, bool) {
+	if u, ok := fv.Interface().(json.Unmarshaler); ok {
+		return u, ok
+	}
+
+	if !fv.CanAddr() {
+		return nil, false
+	}
+
+	u, ok := fv.Addr().Interface().(json.Unmarshaler)
+	return u, ok
+}

attributes_test.go

@@ -0,0 +1,95 @@
+package jsonapi
+
+import (
+	"reflect"
+	"strconv"
+	"testing"
+	"time"
+)
+
+func TestISO8601Datetime(t *testing.T) {
+	pacific, err := time.LoadLocation("America/Los_Angeles")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	type test struct {
+		stringVal string
+		dtVal     ISO8601Datetime
+	}
+
+	tests := []*test{
+		&test{
+			stringVal: strconv.Quote("2017-04-06T13:00:00-07:00"),
+			dtVal:     ISO8601Datetime{Time: time.Date(2017, time.April, 6, 13, 0, 0, 0, pacific)},
+		},
+		&test{
+			stringVal: strconv.Quote("2007-05-06T13:00:00-07:00"),
+			dtVal:     ISO8601Datetime{Time: time.Date(2007, time.May, 6, 13, 0, 0, 0, pacific)},
+		},
+		&test{
+			stringVal: strconv.Quote("2016-12-08T15:18:54Z"),
+			dtVal:     ISO8601Datetime{Time: time.Date(2016, time.December, 8, 15, 18, 54, 0, time.UTC)},
+		},
+	}
+
+	for _, test := range tests {
+		// unmarshal stringVal by calling UnmarshalJSON()
+		dt := &ISO8601Datetime{}
+		if err := dt.UnmarshalJSON([]byte(test.stringVal)); err != nil {
+			t.Fatal(err)
+		}
+
+		// compare unmarshaled stringVal to dtVal
+		if !dt.Time.Equal(test.dtVal.Time) {
+			t.Errorf("\n\tE=%+v\n\tA=%+v", test.dtVal.UnixNano(), dt.UnixNano())
+		}
+
+		// marshal dtVal by calling MarshalJSON()
+		b, err := test.dtVal.MarshalJSON()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// compare marshaled dtVal to stringVal
+		if test.stringVal != string(b) {
+			t.Errorf("\n\tE=%+v\n\tA=%+v", test.stringVal, string(b))
+		}
+	}
+}
+
+func TestIsJSONMarshaler(t *testing.T) {
+	{ // positive
+		isoDateTime := ISO8601Datetime{}
+		v := reflect.ValueOf(&isoDateTime)
+		if _, ok := isJSONMarshaler(v); !ok {
+			t.Error("got false; expected ISO8601Datetime to implement json.Marshaler")
+		}
+	}
+	{ // negative
+		type customString string
+		input := customString("foo")
+		v := reflect.ValueOf(&input)
+		if _, ok := isJSONMarshaler(v); ok {
+			t.Error("got true; expected customString to not implement json.Marshaler")
+		}
+	}
+}
+
+func TestIsJSONUnmarshaler(t *testing.T) {
+	{ // positive
+		isoDateTime := ISO8601Datetime{}
+		v := reflect.ValueOf(&isoDateTime)
+		if _, ok := isJSONUnmarshaler(v); !ok {
+			t.Error("expected ISO8601Datetime to implement json.Unmarshaler")
+		}
+	}
+	{ // negative
+		type customString string
+		input := customString("foo")
+		v := reflect.ValueOf(&input)
+		if _, ok := isJSONUnmarshaler(v); ok {
+			t.Error("got true; expected customString to not implement json.Unmarshaler")
+		}
+	}
+}

request.go

@@ -589,6 +589,11 @@ func handleAttributeUnmarshal(data *Node, args []string, fieldType reflect.Struc
 		return nil
 	}
 
+	// TODO: refactor the time type handlers to implement json.Unmarshaler and move this higher
+	if isJSONUnmarshaler, err := handleJSONUnmarshalerAttributes(data, args, fieldValue); isJSONUnmarshaler {
+		return err
+	}
+
 	// As a final catch-all, ensure types line up to avoid a runtime panic.
 	// Ignore interfaces since interfaces are poly
 	if fieldValue.Kind() != reflect.Interface && fieldValue.Kind() != v.Kind() {
@@ -601,6 +606,35 @@ func handleAttributeUnmarshal(data *Node, args []string, fieldType reflect.Struc
 	return nil
 }
 
+func handleJSONUnmarshalerAttributes(data *Node, args []string, fieldValue reflect.Value) (bool, error) {
+	val := data.Attributes[args[1]]
+
+	// handle struct fields that implement json.Unmarshaler
+	if fieldValue.Type().NumMethod() > 0 {
+		jsonUnmarshaler, ok := isJSONUnmarshaler(fieldValue)
+		// if field doesn't implement the json.Unmarshaler, ignore and move on
+		if !ok {
+			return ok, nil
+		}
+
+		b, err := json.Marshal(val)
+		if err != nil {
+			return ok, err
+		}
+
+		if err := jsonUnmarshaler.UnmarshalJSON(b); err != nil {
+			return ok, err
+		}
+
+		// success; clear value
+		delete(data.Attributes, args[1])
+		return ok, nil
+	}
+
+	// field does not implement any methods, including json.Unmarshaler; continue
+	return false, nil
+}
+
 func fullNode(n *Node, included *map[string]*Node) *Node {
 	includedKey := fmt.Sprintf("%s,%s", n.Type, n.ID)
 

response.go

@@ -215,11 +215,12 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 		structField := modelValue.Type().Field(i)
 		tag := structField.Tag.Get(annotationJSONAPI)
 
+		if shouldIgnoreField(tag) {
+			continue
+		}
+
 		// handles embedded structs
 		if isEmbeddedStruct(structField) {
-			if shouldIgnoreField(tag) {
-				continue
-			}
 			model := modelValue.Field(i).Addr().Interface()
 			embNode, err := visitModelNode(model, included, sideload)
 			if err != nil {
@@ -360,6 +361,11 @@ func visitModelNode(model interface{}, included *map[string]*Node,
 					continue
 				}
 
+				if jsonMarshaler, ok := isJSONMarshaler(fieldValue); ok {
+					node.Attributes[args[1]] = jsonMarshaler
+					continue
+				}
+
 				strAttr, ok := fieldValue.Interface().(string)
 				if ok {
 					node.Attributes[args[1]] = strAttr

response_test.go

@@ -1099,12 +1099,17 @@ func TestMarshalUnmarshalCompositeStruct(t *testing.T) {
 
 	{
 		type Model struct {
-			Thing   `jsonapi:"-"`
-			ModelID int    `jsonapi:"primary,models"`
-			Foo     string `jsonapi:"attr,foo"`
-			Bar     string `jsonapi:"attr,bar"`
-			Bat     string `jsonapi:"attr,bat"`
-			Buzz    int    `jsonapi:"attr,buzz"`
+			Thing      `jsonapi:"-"`
+			ModelID    int             `jsonapi:"primary,models"`
+			Foo        string          `jsonapi:"attr,foo"`
+			Bar        string          `jsonapi:"attr,bar"`
+			Bat        string          `jsonapi:"attr,bat"`
+			Buzz       int             `jsonapi:"attr,buzz"`
+			CreateDate ISO8601Datetime `jsonapi:"attr,create-date"`
+		}
+
+		isoDate := ISO8601Datetime{
+			Time: time.Date(2016, time.December, 8, 15, 18, 54, 0, time.UTC),
 		}
 
 		scenarios = append(scenarios, test{
@@ -1115,19 +1120,21 @@ func TestMarshalUnmarshalCompositeStruct(t *testing.T) {
 					Type: "models",
 					ID:   "1",
 					Attributes: map[string]interface{}{
-						"bar":  "barry",
-						"bat":  "batty",
-						"buzz": 99,
-						"foo":  "fooey",
+						"bar":         "barry",
+						"bat":         "batty",
+						"buzz":        99,
+						"foo":         "fooey",
+						"create-date": isoDate.String(),
 					},
 				},
 			},
 			expected: &Model{
-				ModelID: 1,
-				Foo:     "fooey",
-				Bar:     "barry",
-				Bat:     "batty",
-				Buzz:    99,
+				ModelID:    1,
+				Foo:        "fooey",
+				Bar:        "barry",
+				Bat:        "batty",
+				Buzz:       99,
+				CreateDate: isoDate,
 			},
 		})
 	}