feat(arrow, datetime, decimal, uuid): add support for go-option

Add support for `go-option` to the `arrow`, `datetime`, `decimal`, and `uuid`
packages. This allows for handling optional values of the `Arrow`, `Datetime`,
`Interval`, `Decimal`, `UUID` and `BoxError` types.

The following changes have been made:
- Added `go:generate` directives to the `Arrow`, `Datetime`, `Interval`,
  `Decimal`, `UUID` and `BoxError` types to generate optional types using
  `github.com/tarantool/go-option/cmd/gentypes`.
- Implemented `MarshalMsgpack` and `UnmarshalMsgpack` methods for the `Arrow`,
  `Datetime`, `Interval`, and `Decimal` types.
- Added `marshalUUID` and `unmarshalUUID` functions for the `UUID` type.
- The generated `_gen.go` files contain the `Optional*` types that wrap the
  original types and provide methods to handle optional values, including
  `EncodeMsgpack` and `DecodeMsgpack` for `msgpack` serialization.
- Refactored the `datetime` and `decimal` decoders to use the new
  `UnmarshalMsgpack` methods.

Author: bigbes

arrow/arrow.go

@@ -7,6 +7,8 @@ import (
 	"github.com/vmihailenco/msgpack/v5"
 )
 
+//go:generate go tool gentypes -ext-code 8 Arrow
+
 // Arrow MessagePack extension type.
 const arrowExtId = 8
 
@@ -26,6 +28,17 @@ func (a Arrow) Raw() []byte {
 	return a.data
 }
 
+// MarshalMsgpack implements a custom msgpack marshaler for extension type.
+func (a Arrow) MarshalMsgpack() ([]byte, error) {
+	return a.data, nil
+}
+
+// UnmarshalMsgpack implements a custom msgpack unmarshaler for extension type.
+func (a *Arrow) UnmarshalMsgpack(data []byte) error {
+	a.data = data
+	return nil
+}
+
 func arrowDecoder(d *msgpack.Decoder, v reflect.Value, extLen int) error {
 	arrow := Arrow{
 		data: make([]byte, extLen),

arrow/arrow_gen.go

@@ -0,0 +1,124 @@
+package arrow
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/vmihailenco/msgpack/v5"
+)
+
+func TestSomeOptionalArrow(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	opt := SomeOptionalArrow(val)
+
+	assert.True(t, opt.IsSome())
+	assert.False(t, opt.IsZero())
+
+	v, ok := opt.Get()
+	assert.True(t, ok)
+	assert.Equal(t, val, v)
+}
+
+func TestNoneOptionalArrow(t *testing.T) {
+	opt := NoneOptionalArrow()
+
+	assert.False(t, opt.IsSome())
+	assert.True(t, opt.IsZero())
+
+	_, ok := opt.Get()
+	assert.False(t, ok)
+}
+
+func TestOptionalArrow_MustGet(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	optSome := SomeOptionalArrow(val)
+	optNone := NoneOptionalArrow()
+
+	assert.Equal(t, val, optSome.MustGet())
+	assert.Panics(t, func() { optNone.MustGet() })
+}
+
+func TestOptionalArrow_Unwrap(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	optSome := SomeOptionalArrow(val)
+	optNone := NoneOptionalArrow()
+
+	assert.Equal(t, val, optSome.Unwrap())
+	assert.Equal(t, Arrow{}, optNone.Unwrap())
+}
+
+func TestOptionalArrow_UnwrapOr(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	def, err := MakeArrow([]byte{4, 5, 6})
+	assert.NoError(t, err)
+	optSome := SomeOptionalArrow(val)
+	optNone := NoneOptionalArrow()
+
+	assert.Equal(t, val, optSome.UnwrapOr(def))
+	assert.Equal(t, def, optNone.UnwrapOr(def))
+}
+
+func TestOptionalArrow_UnwrapOrElse(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	def, err := MakeArrow([]byte{4, 5, 6})
+	assert.NoError(t, err)
+	optSome := SomeOptionalArrow(val)
+	optNone := NoneOptionalArrow()
+
+	assert.Equal(t, val, optSome.UnwrapOrElse(func() Arrow { return def }))
+	assert.Equal(t, def, optNone.UnwrapOrElse(func() Arrow { return def }))
+}
+
+func TestOptionalArrow_EncodeDecodeMsgpack_Some(t *testing.T) {
+	val, err := MakeArrow([]byte{1, 2, 3})
+	assert.NoError(t, err)
+	some := SomeOptionalArrow(val)
+
+	var buf bytes.Buffer
+	enc := msgpack.NewEncoder(&buf)
+	dec := msgpack.NewDecoder(&buf)
+
+	err = enc.Encode(some)
+	assert.NoError(t, err)
+
+	var decodedSome OptionalArrow
+	err = dec.Decode(&decodedSome)
+	assert.NoError(t, err)
+	assert.True(t, decodedSome.IsSome())
+	assert.Equal(t, val, decodedSome.Unwrap())
+}
+
+func TestOptionalArrow_EncodeDecodeMsgpack_None(t *testing.T) {
+	none := NoneOptionalArrow()
+
+	var buf bytes.Buffer
+	enc := msgpack.NewEncoder(&buf)
+	dec := msgpack.NewDecoder(&buf)
+
+	err := enc.Encode(none)
+	assert.NoError(t, err)
+
+	var decodedNone OptionalArrow
+	err = dec.Decode(&decodedNone)
+	assert.NoError(t, err)
+	assert.True(t, decodedNone.IsZero())
+}
+
+func TestOptionalArrow_EncodeDecodeMsgpack_InvalidType(t *testing.T) {
+	var buf bytes.Buffer
+	enc := msgpack.NewEncoder(&buf)
+	dec := msgpack.NewDecoder(&buf)
+
+	err := enc.Encode(123)
+	assert.NoError(t, err)
+
+	var decodedInvalid OptionalArrow
+	err = dec.Decode(&decodedInvalid)
+	assert.Error(t, err)
+}