From 133b805f0633a3fcc5f084f9aad4019604e3158e Mon Sep 17 00:00:00 2001 From: Patrick O'brien Date: Fri, 11 Nov 2016 01:40:50 +1000 Subject: [PATCH] Rm duplicates of []byte("null"), began byte type --- bool.go | 2 +- byte.go | 128 ++++++++++++++++++++++++++++++++++++++ byte_test.go | 172 +++++++++++++++++++++++++++++++++++++++++++++++++++ bytes.go | 2 +- float32.go | 5 +- float64.go | 5 +- int.go | 5 +- int16.go | 5 +- int32.go | 5 +- int64.go | 5 +- int8.go | 5 +- json.go | 4 +- string.go | 2 +- time.go | 7 +-- uint.go | 5 +- uint16.go | 5 +- uint32.go | 5 +- uint64.go | 5 +- uint8.go | 11 ++-- 19 files changed, 335 insertions(+), 48 deletions(-) create mode 100644 byte.go create mode 100644 byte_test.go diff --git a/bool.go b/bool.go index 0ad2ea4..be147c8 100644 --- a/bool.go +++ b/bool.go @@ -74,7 +74,7 @@ func (b *Bool) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (b Bool) MarshalJSON() ([]byte, error) { if !b.Valid { - return []byte("null"), nil + return NullBytes, nil } if !b.Bool { return []byte("false"), nil diff --git a/byte.go b/byte.go new file mode 100644 index 0000000..4967c09 --- /dev/null +++ b/byte.go @@ -0,0 +1,128 @@ +package null + +import ( + "bytes" + "database/sql/driver" + "encoding/json" + "errors" + + "gopkg.in/nullbio/null.v5/convert" +) + +// Byte is an nullable int. +type Byte struct { + Byte byte + Valid bool +} + +// NewByte creates a new Byte +func NewByte(b byte, valid bool) Byte { + return Byte{ + Byte: b, + Valid: valid, + } +} + +// ByteFrom creates a new Byte that will always be valid. +func ByteFrom(b byte) Byte { + return NewByte(b, true) +} + +// ByteFromPtr creates a new Byte that be null if i is nil. +func ByteFromPtr(b *byte) Byte { + if b == nil { + return NewByte(0, false) + } + return NewByte(*b, true) +} + +// UnmarshalJSON implements json.Unmarshaler. +func (b *Byte) UnmarshalJSON(data []byte) error { + if len(data) == 0 || bytes.Equal(data, NullBytes) { + b.Valid = false + b.Byte = 0 + return nil + } + + var x string + if err := json.Unmarshal(data, &x); err != nil { + return err + } + + if len(x) > 1 { + return errors.New("json: cannot convert to byte, text len is greater than one") + } + + b.Byte = []byte(x)[0] + b.Valid = true + return nil +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (b *Byte) UnmarshalText(text []byte) error { + if len(text) == 0 { + b.Valid = false + return nil + } + + if len(text) > 1 { + return errors.New("text: cannot convert to byte, text len is greater than one") + } + + b.Valid = true + b.Byte = text[0] + return nil +} + +// MarshalJSON implements json.Marshaler. +func (b Byte) MarshalJSON() ([]byte, error) { + if !b.Valid { + return NullBytes, nil + } + return []byte{b.Byte}, nil +} + +// MarshalText implements encoding.TextMarshaler. +func (b Byte) MarshalText() ([]byte, error) { + if !b.Valid { + return []byte{}, nil + } + return []byte{b.Byte}, nil +} + +// SetValid changes this Byte's value and also sets it to be non-null. +func (b *Byte) SetValid(n byte) { + b.Byte = n + b.Valid = true +} + +// Ptr returns a pointer to this Byte's value, or a nil pointer if this Byte is null. +func (b Byte) Ptr() *byte { + if !b.Valid { + return nil + } + return &b.Byte +} + +// IsZero returns true for invalid Bytes, for future omitempty support (Go 1.4?) +func (b Byte) IsZero() bool { + return !b.Valid +} + +// Scan implements the Scanner interface. +func (b *Byte) Scan(value interface{}) error { + if value == nil { + b.Byte, b.Valid = 0, false + return nil + } + b.Valid = true + return convert.ConvertAssign(&b.Byte, value) +} + +// Value implements the driver Valuer interface. +func (b Byte) Value() (driver.Value, error) { + if !b.Valid { + return nil, nil + } + return []byte{b.Byte}, nil +} diff --git a/byte_test.go b/byte_test.go new file mode 100644 index 0000000..608ec5b --- /dev/null +++ b/byte_test.go @@ -0,0 +1,172 @@ +package null + +import ( + "encoding/json" + "testing" +) + +var ( + byteJSON = []byte(`"b"`) +) + +func TestByteFrom(t *testing.T) { + i := ByteFrom(12345) + assertByte(t, i, "ByteFrom()") + + zero := ByteFrom(0) + if !zero.Valid { + t.Error("ByteFrom(0)", "is invalid, but should be valid") + } +} + +func TestByteFromPtr(t *testing.T) { + n := int(12345) + iptr := &n + i := ByteFromPtr(iptr) + assertByte(t, i, "ByteFromPtr()") + + null := ByteFromPtr(nil) + assertNullByte(t, null, "ByteFromPtr(nil)") +} + +func TestUnmarshalByte(t *testing.T) { + var i Byte + err := json.Unmarshal(intJSON, &i) + maybePanic(err) + assertByte(t, i, "int json") + + var null Byte + err = json.Unmarshal(nullJSON, &null) + maybePanic(err) + assertNullByte(t, null, "null json") + + var badType Byte + err = json.Unmarshal(boolJSON, &badType) + if err == nil { + panic("err should not be nil") + } + assertNullByte(t, badType, "wrong type json") + + var invalid Byte + err = invalid.UnmarshalJSON(invalidJSON) + if _, ok := err.(*json.SyntaxError); !ok { + t.Errorf("expected json.SyntaxError, not %T", err) + } + assertNullByte(t, invalid, "invalid json") +} + +func TestUnmarshalNonByteegerNumber(t *testing.T) { + var i Byte + err := json.Unmarshal(float64JSON, &i) + if err == nil { + panic("err should be present; non-integer number coerced to int") + } +} + +func TestTextUnmarshalByte(t *testing.T) { + var i Byte + err := i.UnmarshalText([]byte("12345")) + maybePanic(err) + assertByte(t, i, "UnmarshalText() int") + + var blank Byte + err = blank.UnmarshalText([]byte("")) + maybePanic(err) + assertNullByte(t, blank, "UnmarshalText() empty int") + + var null Byte + err = null.UnmarshalText([]byte("null")) + maybePanic(err) + assertNullByte(t, null, `UnmarshalText() "null"`) +} + +func TestMarshalByte(t *testing.T) { + i := ByteFrom(12345) + data, err := json.Marshal(i) + maybePanic(err) + assertJSONEquals(t, data, "12345", "non-empty json marshal") + + // invalid values should be encoded as null + null := NewByte(0, false) + data, err = json.Marshal(null) + maybePanic(err) + assertJSONEquals(t, data, "null", "null json marshal") +} + +func TestMarshalByteText(t *testing.T) { + i := ByteFrom(12345) + data, err := i.MarshalText() + maybePanic(err) + assertJSONEquals(t, data, "12345", "non-empty text marshal") + + // invalid values should be encoded as null + null := NewByte(0, false) + data, err = null.MarshalText() + maybePanic(err) + assertJSONEquals(t, data, "", "null text marshal") +} + +func TestBytePointer(t *testing.T) { + i := ByteFrom(12345) + ptr := i.Ptr() + if *ptr != 12345 { + t.Errorf("bad %s int: %#v ≠ %d\n", "pointer", ptr, 12345) + } + + null := NewByte(0, false) + ptr = null.Ptr() + if ptr != nil { + t.Errorf("bad %s int: %#v ≠ %s\n", "nil pointer", ptr, "nil") + } +} + +func TestByteIsZero(t *testing.T) { + i := ByteFrom(12345) + if i.IsZero() { + t.Errorf("IsZero() should be false") + } + + null := NewByte(0, false) + if !null.IsZero() { + t.Errorf("IsZero() should be true") + } + + zero := NewByte(0, true) + if zero.IsZero() { + t.Errorf("IsZero() should be false") + } +} + +func TestByteSetValid(t *testing.T) { + change := NewByte(0, false) + assertNullByte(t, change, "SetValid()") + change.SetValid(12345) + assertByte(t, change, "SetValid()") +} + +func TestByteScan(t *testing.T) { + var i Byte + err := i.Scan(12345) + maybePanic(err) + assertByte(t, i, "scanned int") + + var null Byte + err = null.Scan(nil) + maybePanic(err) + assertNullByte(t, null, "scanned null") +} + +func assertByte(t *testing.T, i Byte, from string) { + if i.Byte != 12345 { + t.Errorf("bad %s int: %d ≠ %d\n", from, i.Byte, 12345) + } + if !i.Valid { + t.Error(from, "is invalid, but should be valid") + } +} + +func assertNullByte(t *testing.T, i Byte, from string) { + if i.Valid { + t.Error(from, "is valid, but should be invalid") + } +} diff --git a/bytes.go b/bytes.go index b59736f..1d89fe6 100644 --- a/bytes.go +++ b/bytes.go @@ -73,7 +73,7 @@ func (b *Bytes) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (b Bytes) MarshalJSON() ([]byte, error) { if len(b.Bytes) == 0 || b.Bytes == nil { - return []byte("null"), nil + return NullBytes, nil } return b.Bytes, nil } diff --git a/float32.go b/float32.go index fba24c0..32883c1 100644 --- a/float32.go +++ b/float32.go @@ -56,8 +56,7 @@ func (f *Float32) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (f *Float32) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { f.Valid = false return nil } @@ -73,7 +72,7 @@ func (f *Float32) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (f Float32) MarshalJSON() ([]byte, error) { if !f.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatFloat(float64(f.Float32), 'f', -1, 32)), nil } diff --git a/float64.go b/float64.go index 90e02f9..3c64e61 100644 --- a/float64.go +++ b/float64.go @@ -54,8 +54,7 @@ func (f *Float64) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (f *Float64) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { f.Valid = false return nil } @@ -68,7 +67,7 @@ func (f *Float64) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (f Float64) MarshalJSON() ([]byte, error) { if !f.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatFloat(f.Float64, 'f', -1, 64)), nil } diff --git a/int.go b/int.go index ba69e23..854aab3 100644 --- a/int.go +++ b/int.go @@ -56,8 +56,7 @@ func (i *Int) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (i *Int) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { i.Valid = false return nil } @@ -73,7 +72,7 @@ func (i *Int) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (i Int) MarshalJSON() ([]byte, error) { if !i.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatInt(int64(i.Int), 10)), nil } diff --git a/int16.go b/int16.go index 119a4cc..2ac9f99 100644 --- a/int16.go +++ b/int16.go @@ -62,8 +62,7 @@ func (i *Int16) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (i *Int16) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { i.Valid = false return nil } @@ -79,7 +78,7 @@ func (i *Int16) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (i Int16) MarshalJSON() ([]byte, error) { if !i.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatInt(int64(i.Int16), 10)), nil } diff --git a/int32.go b/int32.go index f4c897d..ad3e132 100644 --- a/int32.go +++ b/int32.go @@ -62,8 +62,7 @@ func (i *Int32) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (i *Int32) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { i.Valid = false return nil } @@ -79,7 +78,7 @@ func (i *Int32) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (i Int32) MarshalJSON() ([]byte, error) { if !i.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatInt(int64(i.Int32), 10)), nil } diff --git a/int64.go b/int64.go index 2157899..29759dd 100644 --- a/int64.go +++ b/int64.go @@ -54,8 +54,7 @@ func (i *Int64) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (i *Int64) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { i.Valid = false return nil } @@ -68,7 +67,7 @@ func (i *Int64) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (i Int64) MarshalJSON() ([]byte, error) { if !i.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatInt(i.Int64, 10)), nil } diff --git a/int8.go b/int8.go index 6036ef7..19eece3 100644 --- a/int8.go +++ b/int8.go @@ -62,8 +62,7 @@ func (i *Int8) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (i *Int8) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { i.Valid = false return nil } @@ -79,7 +78,7 @@ func (i *Int8) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (i Int8) MarshalJSON() ([]byte, error) { if !i.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatInt(int64(i.Int8), 10)), nil } diff --git a/json.go b/json.go index 4720981..8d7e89a 100644 --- a/json.go +++ b/json.go @@ -64,7 +64,7 @@ func (j *JSON) UnmarshalJSON(data []byte) error { } if bytes.Equal(data, NullBytes) { - j.JSON = []byte("null") + j.JSON = NullBytes j.Valid = false return nil } @@ -106,7 +106,7 @@ func (j *JSON) Marshal(obj interface{}) error { // MarshalJSON implements json.Marshaler. func (j JSON) MarshalJSON() ([]byte, error) { if len(j.JSON) == 0 || j.JSON == nil { - return []byte("null"), nil + return NullBytes, nil } return j.JSON, nil } diff --git a/string.go b/string.go index 97c764e..9f868a9 100644 --- a/string.go +++ b/string.go @@ -54,7 +54,7 @@ func (s *String) UnmarshalJSON(data []byte) error { // MarshalJSON implements json.Marshaler. func (s String) MarshalJSON() ([]byte, error) { if !s.Valid { - return []byte("null"), nil + return NullBytes, nil } return json.Marshal(s.String) } diff --git a/time.go b/time.go index efc5d67..3cd0af1 100644 --- a/time.go +++ b/time.go @@ -37,7 +37,7 @@ func TimeFromPtr(t *time.Time) Time { // MarshalJSON implements json.Marshaler. func (t Time) MarshalJSON() ([]byte, error) { if !t.Valid { - return []byte("null"), nil + return NullBytes, nil } return t.Time.MarshalJSON() } @@ -61,15 +61,14 @@ func (t *Time) UnmarshalJSON(data []byte) error { // MarshalText implements encoding.TextMarshaler. func (t Time) MarshalText() ([]byte, error) { if !t.Valid { - return []byte("null"), nil + return NullBytes, nil } return t.Time.MarshalText() } // UnmarshalText implements encoding.TextUnmarshaler. func (t *Time) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { t.Valid = false return nil } diff --git a/uint.go b/uint.go index d8c4b53..4331494 100644 --- a/uint.go +++ b/uint.go @@ -56,8 +56,7 @@ func (u *Uint) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (u *Uint) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { u.Valid = false return nil } @@ -73,7 +72,7 @@ func (u *Uint) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (u Uint) MarshalJSON() ([]byte, error) { if !u.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatUint(uint64(u.Uint), 10)), nil } diff --git a/uint16.go b/uint16.go index 74b11ae..4edb211 100644 --- a/uint16.go +++ b/uint16.go @@ -62,8 +62,7 @@ func (u *Uint16) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (u *Uint16) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { u.Valid = false return nil } @@ -79,7 +78,7 @@ func (u *Uint16) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (u Uint16) MarshalJSON() ([]byte, error) { if !u.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatUint(uint64(u.Uint16), 10)), nil } diff --git a/uint32.go b/uint32.go index 25c52be..920b105 100644 --- a/uint32.go +++ b/uint32.go @@ -62,8 +62,7 @@ func (u *Uint32) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (u *Uint32) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { u.Valid = false return nil } @@ -79,7 +78,7 @@ func (u *Uint32) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (u Uint32) MarshalJSON() ([]byte, error) { if !u.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatUint(uint64(u.Uint32), 10)), nil } diff --git a/uint64.go b/uint64.go index 4c3cf5d..df2f26e 100644 --- a/uint64.go +++ b/uint64.go @@ -54,8 +54,7 @@ func (u *Uint64) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (u *Uint64) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { u.Valid = false return nil } @@ -71,7 +70,7 @@ func (u *Uint64) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (u Uint64) MarshalJSON() ([]byte, error) { if !u.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatUint(u.Uint64, 10)), nil } diff --git a/uint8.go b/uint8.go index 2aeef53..76ed02a 100644 --- a/uint8.go +++ b/uint8.go @@ -62,8 +62,7 @@ func (u *Uint8) UnmarshalJSON(data []byte) error { // UnmarshalText implements encoding.TextUnmarshaler. func (u *Uint8) UnmarshalText(text []byte) error { - str := string(text) - if str == "" || str == "null" { + if len(text) == 0 || bytes.Equal(text, NullBytes) { u.Valid = false return nil } @@ -79,7 +78,7 @@ func (u *Uint8) UnmarshalText(text []byte) error { // MarshalJSON implements json.Marshaler. func (u Uint8) MarshalJSON() ([]byte, error) { if !u.Valid { - return []byte("null"), nil + return NullBytes, nil } return []byte(strconv.FormatUint(uint64(u.Uint8), 10)), nil } @@ -122,9 +121,9 @@ func (u *Uint8) Scan(value interface{}) error { } // Value implements the driver Valuer interface. -func (n Uint8) Value() (driver.Value, error) { - if !n.Valid { +func (u Uint8) Value() (driver.Value, error) { + if !u.Valid { return nil, nil } - return int64(n.Uint8), nil + return int64(u.Uint8), nil }