chore(deps): bump github.com/shamaton/msgpack/v2 from 2.2.0 to 2.2.2

Bumps [github.com/shamaton/msgpack/v2](https://github.com/shamaton/msgpack) from 2.2.0 to 2.2.2.
- [Release notes](https://github.com/shamaton/msgpack/releases)
- [Commits](https://github.com/shamaton/msgpack/compare/v2.2.0...v2.2.2)

---
updated-dependencies:
- dependency-name: github.com/shamaton/msgpack/v2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

go.mod

@@ -80,7 +80,7 @@ require (
 	github.com/rogpeppe/go-internal v1.12.0
 	github.com/rs/cors v1.11.0
 	github.com/rs/zerolog v1.33.0
-	github.com/shamaton/msgpack/v2 v2.2.0
+	github.com/shamaton/msgpack/v2 v2.2.2
 	github.com/sirupsen/logrus v1.9.3
 	github.com/spf13/afero v1.11.0
 	github.com/spf13/cobra v1.8.1

go.sum

@@ -1078,8 +1078,8 @@ github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
 github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/sethvargo/go-password v0.2.0 h1:BTDl4CC/gjf/axHMaDQtw507ogrXLci6XRiLc7i/UHI=
 github.com/sethvargo/go-password v0.2.0/go.mod h1:Ym4Mr9JXLBycr02MFuVQ/0JHidNetSgbzutTr3zsYXE=
-github.com/shamaton/msgpack/v2 v2.2.0 h1:IP1m01pHwCrMa6ZccP9B3bqxEMKMSmMVAVKk54g3L/Y=
-github.com/shamaton/msgpack/v2 v2.2.0/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI=
+github.com/shamaton/msgpack/v2 v2.2.2 h1:GOIg0c9LV04VwzOOqZSrmsv/JzjNOOMxnS/HvOHGdgs=
+github.com/shamaton/msgpack/v2 v2.2.2/go.mod h1:6khjYnkx73f7VQU7wjcFS9DFjs+59naVWJv1TB7qdOI=
 github.com/shirou/gopsutil v3.21.11+incompatible h1:+1+c1VGhc88SSonWP6foOcLhvnKlUeu/erjjvaPEYiI=
 github.com/shirou/gopsutil v3.21.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
 github.com/shurcooL/httpfs v0.0.0-20190707220628-8d4bc4ba7749 h1:bUGsEnyNbVPw06Bs80sCeARAlK8lhwqGyi6UT8ymuGk=

vendor/github.com/shamaton/msgpack/v2/.travis.yml

@@ -1,28 +0,0 @@
-language: go
-
-services:
-  - docker
-
-go:
-  - "1.9.x"
-  - "1.10.x"
-  - "1.11.x"
-  - "1.12.x"
-  - "1.13.x"
-  - "1.14.x"
-  - "1.15.x"
-  - tip
-
-before_install:
-  - go get github.com/axw/gocov/gocov
-  - go get github.com/mattn/goveralls
-  - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
-  - docker pull i386/golang:1.12-alpine
-  - docker run -dit --name test i386/golang:1.12-alpine sh
-  - docker exec test sh -c "apk add --no-cache git"
-  - docker exec test sh -c "go get github.com/shamaton/msgpack"
-  - docker exec test sh -c "cd /go/src/github.com/shamaton/msgpack && git checkout `git rev-parse --abbrev-ref HEAD`"
-
-script:
-  - docker exec test sh -c "cd /go/src/github.com/shamaton/msgpack && go test -v ."
-  - $GOPATH/bin/goveralls -service=travis-ci

vendor/github.com/shamaton/msgpack/v2/codecov.yml

@@ -0,0 +1,4 @@
+coverage:
+  status:
+    project: off
+    patch: off

vendor/github.com/shamaton/msgpack/v2/def/error.go

@@ -0,0 +1,31 @@
+package def
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	// base errors
+
+	ErrMsgpack = errors.New("")
+
+	// decoding errors
+
+	ErrNoData                 = fmt.Errorf("%wno data", ErrMsgpack)
+	ErrHasLeftOver            = fmt.Errorf("%wdata has left over", ErrMsgpack)
+	ErrReceiverNotPointer     = fmt.Errorf("%wreceiver not pointer", ErrMsgpack)
+	ErrNotMatchArrayElement   = fmt.Errorf("%wnot match array element", ErrMsgpack)
+	ErrCanNotDecode           = fmt.Errorf("%winvalid code", ErrMsgpack)
+	ErrCanNotSetSliceAsMapKey = fmt.Errorf("%wcan not set slice as map key", ErrMsgpack)
+	ErrCanNotSetMapAsMapKey   = fmt.Errorf("%wcan not set map as map key", ErrMsgpack)
+
+	// encoding errors
+
+	ErrTooShortBytes         = fmt.Errorf("%wtoo short bytes", ErrMsgpack)
+	ErrLackDataLengthToSlice = fmt.Errorf("%wdata length lacks to create slice", ErrMsgpack)
+	ErrLackDataLengthToMap   = fmt.Errorf("%wdata length lacks to create map", ErrMsgpack)
+	ErrUnsupportedType       = fmt.Errorf("%wunsupported type", ErrMsgpack)
+	ErrUnsupportedLength     = fmt.Errorf("%wunsupported length", ErrMsgpack)
+	ErrNotMatchLastIndex     = fmt.Errorf("%wnot match last index", ErrMsgpack)
+)

vendor/github.com/shamaton/msgpack/v2/errors.go

@@ -0,0 +1,8 @@
+package msgpack
+
+import (
+	"github.com/shamaton/msgpack/v2/def"
+)
+
+// Error is used in all msgpack error as the based error.
+var Error = def.ErrMsgpack

vendor/github.com/shamaton/msgpack/v2/ext/decoder_stream.go

@@ -1,60 +1,11 @@
 package ext
 
 import (
-	"github.com/shamaton/msgpack/v2/internal/common"
-	"io"
 	"reflect"
 )
 
-var emptyBytes []byte
-
 type StreamDecoder interface {
 	Code() int8
 	IsType(code byte, innerType int8, dataLength int) bool
 	ToValue(code byte, data []byte, k reflect.Kind) (any, error)
 }
-
-type DecoderStreamCommon struct {
-}
-
-func (d *DecoderStreamCommon) ReadSize1(r io.Reader, buf *common.Buffer) (byte, error) {
-	if _, err := r.Read(buf.B1); err != nil {
-		return 0, err
-	}
-	return buf.B1[0], nil
-}
-
-func (d *DecoderStreamCommon) ReadSize2(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B2); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B2, nil
-}
-
-func (d *DecoderStreamCommon) ReadSize4(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B4); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B4, nil
-}
-
-func (d *DecoderStreamCommon) ReadSize8(r io.Reader, buf *common.Buffer) ([]byte, error) {
-	if _, err := r.Read(buf.B8); err != nil {
-		return emptyBytes, err
-	}
-	return buf.B8, nil
-}
-
-func (d *DecoderStreamCommon) ReadSizeN(r io.Reader, buf *common.Buffer, n int) ([]byte, error) {
-	var b []byte
-	if len(buf.Data) <= n {
-		b = buf.Data[:n]
-	} else {
-		buf.Data = append(buf.Data, make([]byte, n-len(buf.Data))...)
-		b = buf.Data
-	}
-	if _, err := r.Read(b); err != nil {
-		return emptyBytes, err
-	}
-	return b, nil
-}

vendor/github.com/shamaton/msgpack/v2/ext/encode_stream.go

@@ -1,34 +1,44 @@
 package ext
 
 import (
-	"github.com/shamaton/msgpack/v2/internal/common"
 	"io"
 	"reflect"
+
+	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
+// StreamEncoder is interface that extended encoder should implement
 type StreamEncoder interface {
 	Code() int8
 	Type() reflect.Type
-	Write(w io.Writer, value reflect.Value, buf *common.Buffer) error
+	Write(w StreamWriter, value reflect.Value) error
 }
 
-type StreamEncoderCommon struct{}
+// StreamWriter is provided some writing functions for extended format by user
+type StreamWriter struct {
+	w   io.Writer
+	buf *common.Buffer
+}
 
-func (c *StreamEncoderCommon) WriteByte1Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func CreateStreamWriter(w io.Writer, buf *common.Buffer) StreamWriter {
+	return StreamWriter{w, buf}
+}
+
+func (w *StreamWriter) WriteByte1Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -36,8 +46,8 @@ func (c *StreamEncoderCommon) WriteByte4Int64(w io.Writer, value int64, buf *com
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte8Int64(w io.Writer, value int64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte8Int64(value int64) error {
+	return w.buf.Write(w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -49,21 +59,21 @@ func (c *StreamEncoderCommon) WriteByte8Int64(w io.Writer, value int64, buf *com
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte1Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte1Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -71,8 +81,8 @@ func (c *StreamEncoderCommon) WriteByte4Uint64(w io.Writer, value uint64, buf *c
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte8Uint64(w io.Writer, value uint64, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte8Uint64(value uint64) error {
+	return w.buf.Write(w.w,
 		byte(value>>56),
 		byte(value>>48),
 		byte(value>>40),
@@ -84,21 +94,21 @@ func (c *StreamEncoderCommon) WriteByte8Uint64(w io.Writer, value uint64, buf *c
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte1Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte1Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte2Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte2Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value>>8),
 		byte(value),
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Int(w io.Writer, value int, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Int(value int) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -106,8 +116,8 @@ func (c *StreamEncoderCommon) WriteByte4Int(w io.Writer, value int, buf *common.
 	)
 }
 
-func (c *StreamEncoderCommon) WriteByte4Uint32(w io.Writer, value uint32, buf *common.Buffer) error {
-	return buf.Write(w,
+func (w *StreamWriter) WriteByte4Uint32(value uint32) error {
+	return w.buf.Write(w.w,
 		byte(value>>24),
 		byte(value>>16),
 		byte(value>>8),
@@ -115,6 +125,6 @@ func (c *StreamEncoderCommon) WriteByte4Uint32(w io.Writer, value uint32, buf *c
 	)
 }
 
-func (c *StreamEncoderCommon) WriteBytes(w io.Writer, bs []byte, buf *common.Buffer) error {
-	return buf.Write(w, bs...)
+func (w *StreamWriter) WriteBytes(bs []byte) error {
+	return w.buf.Write(w.w, bs...)
 }

vendor/github.com/shamaton/msgpack/v2/internal/common/buffer.go

@@ -18,13 +18,13 @@ type Buffer struct {
 func (b *Buffer) Write(w io.Writer, vs ...byte) error {
 	if len(b.Data) < b.offset+len(vs) {
 		_, err := w.Write(b.Data[:b.offset])
+		b.offset = 0
 		if err != nil {
 			return err
 		}
 		if len(b.Data) < len(vs) {
 			b.Data = append(b.Data, make([]byte, len(vs)-len(b.Data))...)
 		}
-		b.offset = 0
 	}
 	for i := range vs {
 		b.Data[b.offset+i] = vs[i]

vendor/github.com/shamaton/msgpack/v2/internal/decoding/bin.go

@@ -28,22 +28,31 @@ func (d *decoder) asBin(offset int, k reflect.Kind) ([]byte, int, error) {
 		if err != nil {
 			return emptyBytes, 0, err
 		}
-		o := offset + int(uint8(l))
-		return d.data[offset:o], o, nil
+		v, offset, err := d.readSizeN(offset, int(uint8(l)))
+		if err != nil {
+			return emptyBytes, 0, err
+		}
+		return v, offset, nil
 	case def.Bin16:
 		bs, offset, err := d.readSize2(offset)
-		o := offset + int(binary.BigEndian.Uint16(bs))
 		if err != nil {
 			return emptyBytes, 0, err
 		}
-		return d.data[offset:o], o, nil
+		v, offset, err := d.readSizeN(offset, int(binary.BigEndian.Uint16(bs)))
+		if err != nil {
+			return emptyBytes, 0, err
+		}
+		return v, offset, nil
 	case def.Bin32:
 		bs, offset, err := d.readSize4(offset)
-		o := offset + int(binary.BigEndian.Uint32(bs))
 		if err != nil {
 			return emptyBytes, 0, err
 		}
-		return d.data[offset:o], o, nil
+		v, offset, err := d.readSizeN(offset, int(binary.BigEndian.Uint32(bs)))
+		if err != nil {
+			return emptyBytes, 0, err
+		}
+		return v, offset, nil
 	}
 
 	return emptyBytes, 0, d.errorTemplate(code, k)

vendor/github.com/shamaton/msgpack/v2/internal/decoding/bool.go

@@ -7,8 +7,10 @@ import (
 )
 
 func (d *decoder) asBool(offset int, k reflect.Kind) (bool, int, error) {
-	code := d.data[offset]
-	offset++
+	code, offset, err := d.readSize1(offset)
+	if err != nil {
+		return false, 0, err
+	}
 
 	switch code {
 	case def.True:

vendor/github.com/shamaton/msgpack/v2/internal/decoding/complex.go

@@ -58,7 +58,7 @@ func (d *decoder) asComplex64(offset int, k reflect.Kind) (complex64, int, error
 
 	}
 
-	return complex(0, 0), 0, fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
+	return complex(0, 0), 0, d.errorTemplate(code, k)
 }
 
 func (d *decoder) asComplex128(offset int, k reflect.Kind) (complex128, int, error) {
@@ -110,5 +110,5 @@ func (d *decoder) asComplex128(offset int, k reflect.Kind) (complex128, int, err
 
 	}
 
-	return complex(0, 0), 0, fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
+	return complex(0, 0), 0, d.errorTemplate(code, k)
 }

vendor/github.com/shamaton/msgpack/v2/internal/decoding/decoding.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/shamaton/msgpack/v2/def"
 	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
@@ -19,11 +20,11 @@ func Decode(data []byte, v interface{}, asArray bool) error {
 	d := decoder{data: data, asArray: asArray}
 
 	if d.data == nil || len(d.data) < 1 {
-		return fmt.Errorf("data is empty")
+		return def.ErrNoData
 	}
 	rv := reflect.ValueOf(v)
 	if rv.Kind() != reflect.Ptr {
-		return fmt.Errorf("holder must set pointer value. but got: %t", v)
+		return fmt.Errorf("%w. v.(type): %T", def.ErrReceiverNotPointer, v)
 	}
 
 	rv = rv.Elem()
@@ -33,7 +34,7 @@ func Decode(data []byte, v interface{}, asArray bool) error {
 		return err
 	}
 	if len(data) != last {
-		return fmt.Errorf("failed deserialization size=%d, last=%d", len(data), last)
+		return fmt.Errorf("%w size=%d, last=%d", def.ErrHasLeftOver, len(data), last)
 	}
 	return err
 }
@@ -191,7 +192,7 @@ func (d *decoder) decode(rv reflect.Value, offset int) (int, error) {
 				return 0, err
 			}
 			if len(bs) > rv.Len() {
-				return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), len(bs))
+				return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), len(bs), def.ErrNotMatchArrayElement)
 			}
 			for i, b := range bs {
 				rv.Index(i).SetUint(uint64(b))
@@ -205,7 +206,7 @@ func (d *decoder) decode(rv reflect.Value, offset int) (int, error) {
 				return 0, err
 			}
 			if l > rv.Len() {
-				return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
+				return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), l, def.ErrNotMatchArrayElement)
 			}
 			bs, offset, err := d.asStringByteByLength(offset, l, k)
 			if err != nil {
@@ -224,7 +225,7 @@ func (d *decoder) decode(rv reflect.Value, offset int) (int, error) {
 		}
 
 		if l > rv.Len() {
-			return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
+			return 0, fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), l, def.ErrNotMatchArrayElement)
 		}
 
 		if err = d.hasRequiredLeastSliceSize(o, l); err != nil {
@@ -332,11 +333,11 @@ func (d *decoder) decode(rv reflect.Value, offset int) (int, error) {
 		}
 
 	default:
-		return 0, fmt.Errorf("type(%v) is unsupported", rv.Kind())
+		return 0, fmt.Errorf("%v is %w type", rv.Kind(), def.ErrUnsupportedType)
 	}
 	return offset, nil
 }
 
 func (d *decoder) errorTemplate(code byte, k reflect.Kind) error {
-	return fmt.Errorf("msgpack : invalid code %x decoding %v", code, k)
+	return fmt.Errorf("%w %x decoding as %v", def.ErrCanNotDecode, code, k)
 }

vendor/github.com/shamaton/msgpack/v2/internal/decoding/float.go

@@ -27,14 +27,14 @@ func (d *decoder) asFloat32(offset int, k reflect.Kind) (float32, int, error) {
 	case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
 		v, offset, err := d.asUint(offset, k)
 		if err != nil {
-			break
+			return 0, 0, err
 		}
 		return float32(v), offset, nil
 
 	case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
 		v, offset, err := d.asInt(offset, k)
 		if err != nil {
-			break
+			return 0, 0, err
 		}
 		return float32(v), offset, nil
 
@@ -73,14 +73,14 @@ func (d *decoder) asFloat64(offset int, k reflect.Kind) (float64, int, error) {
 	case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
 		v, offset, err := d.asUint(offset, k)
 		if err != nil {
-			break
+			return 0, 0, err
 		}
 		return float64(v), offset, nil
 
 	case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
 		v, offset, err := d.asInt(offset, k)
 		if err != nil {
-			break
+			return 0, 0, err
 		}
 		return float64(v), offset, nil
 

vendor/github.com/shamaton/msgpack/v2/internal/decoding/interface.go

@@ -134,7 +134,7 @@ func (d *decoder) asInterface(offset int, k reflect.Kind) (interface{}, int, err
 		}
 		v := make(map[interface{}]interface{}, l)
 		for i := 0; i < l; i++ {
-			if d.canSetAsMapKey(o) != nil {
+			if err := d.canSetAsMapKey(o); err != nil {
 				return nil, 0, err
 			}
 			key, o2, err := d.asInterface(o, k)
@@ -182,9 +182,9 @@ func (d *decoder) canSetAsMapKey(index int) error {
 	}
 	switch {
 	case d.isFixSlice(code), code == def.Array16, code == def.Array32:
-		return fmt.Errorf("can not use slice code for map key/ code: %x", code)
+		return fmt.Errorf("%w. code: %x", def.ErrCanNotSetSliceAsMapKey, code)
 	case d.isFixMap(code), code == def.Map16, code == def.Map32:
-		return fmt.Errorf("can not use map code for map key/ code: %x", code)
+		return fmt.Errorf("%w. code: %x", def.ErrCanNotSetMapAsMapKey, code)
 	}
 	return nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/decoding/map.go

@@ -2,7 +2,6 @@ package decoding
 
 import (
 	"encoding/binary"
-	"errors"
 	"reflect"
 
 	"github.com/shamaton/msgpack/v2/def"
@@ -88,7 +87,7 @@ func (d *decoder) mapLength(offset int, k reflect.Kind) (int, int, error) {
 func (d *decoder) hasRequiredLeastMapSize(offset, length int) error {
 	// minimum check (byte length)
 	if len(d.data[offset:]) < length*2 {
-		return errors.New("data length lacks to create map")
+		return def.ErrLackDataLengthToMap
 	}
 	return nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/decoding/read.go

@@ -1,15 +1,13 @@
 package decoding
 
 import (
-	"errors"
-
 	"github.com/shamaton/msgpack/v2/def"
 )
 
 func (d *decoder) readSize1(index int) (byte, int, error) {
 	rb := def.Byte1
 	if len(d.data) < index+rb {
-		return 0, 0, errors.New("too short bytes")
+		return 0, 0, def.ErrTooShortBytes
 	}
 	return d.data[index], index + rb, nil
 }
@@ -28,7 +26,7 @@ func (d *decoder) readSize8(index int) ([]byte, int, error) {
 
 func (d *decoder) readSizeN(index, n int) ([]byte, int, error) {
 	if len(d.data) < index+n {
-		return emptyBytes, 0, errors.New("too short bytes")
+		return emptyBytes, 0, def.ErrTooShortBytes
 	}
 	return d.data[index : index+n], index + n, nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/decoding/slice.go

@@ -2,7 +2,6 @@ package decoding
 
 import (
 	"encoding/binary"
-	"errors"
 	"reflect"
 
 	"github.com/shamaton/msgpack/v2/def"
@@ -61,7 +60,7 @@ func (d *decoder) sliceLength(offset int, k reflect.Kind) (int, int, error) {
 func (d *decoder) hasRequiredLeastSliceSize(offset, length int) error {
 	// minimum check (byte length)
 	if len(d.data[offset:]) < length {
-		return errors.New("data length lacks to create map")
+		return def.ErrLackDataLengthToSlice
 	}
 	return nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/encoding/byte.go

@@ -23,7 +23,7 @@ func (e *encoder) calcByteSlice(l int) (int, error) {
 		return def.Byte4 + l, nil
 	}
 	// not supported error
-	return 0, fmt.Errorf("not support this array length : %d", l)
+	return 0, fmt.Errorf("%w slice length : %d", def.ErrUnsupportedType, l)
 }
 
 func (e *encoder) writeByteSliceLength(l int, offset int) int {

vendor/github.com/shamaton/msgpack/v2/internal/encoding/encoding.go

@@ -45,7 +45,7 @@ func Encode(v interface{}, asArray bool) (b []byte, err error) {
 	e.d = make([]byte, size)
 	last := e.create(rv, 0)
 	if size != last {
-		return nil, fmt.Errorf("failed serialization size=%d, lastIdx=%d", size, last)
+		return nil, fmt.Errorf("%w size=%d, lastIdx=%d", def.ErrNotMatchLastIndex, size, last)
 	}
 	return e.d, err
 }
@@ -116,7 +116,7 @@ func (e *encoder) calcSize(rv reflect.Value) (int, error) {
 			ret += def.Byte4
 		} else {
 			// not supported error
-			return 0, fmt.Errorf("not support this array length : %d", l)
+			return 0, fmt.Errorf("%w array length : %d", def.ErrUnsupportedType, l)
 		}
 
 		if size, find := e.calcFixedSlice(rv); find {
@@ -164,7 +164,7 @@ func (e *encoder) calcSize(rv reflect.Value) (int, error) {
 			ret += def.Byte4
 		} else {
 			// not supported error
-			return 0, fmt.Errorf("not support this array length : %d", l)
+			return 0, fmt.Errorf("array length %d is %w", l, def.ErrUnsupportedLength)
 		}
 
 		// func
@@ -201,7 +201,7 @@ func (e *encoder) calcSize(rv reflect.Value) (int, error) {
 			ret += def.Byte4
 		} else {
 			// not supported error
-			return 0, fmt.Errorf("not support this map length : %d", l)
+			return 0, fmt.Errorf("map length %d is %w", l, def.ErrUnsupportedLength)
 		}
 
 		if size, find := e.calcFixedMap(rv); find {
@@ -262,7 +262,7 @@ func (e *encoder) calcSize(rv reflect.Value) (int, error) {
 		// do nothing (return nil)
 
 	default:
-		return 0, fmt.Errorf("type(%v) is unsupported", rv.Kind())
+		return 0, fmt.Errorf("%v is %w type", rv.Kind(), def.ErrUnsupportedType)
 	}
 
 	return ret, nil

vendor/github.com/shamaton/msgpack/v2/internal/encoding/struct.go

@@ -95,7 +95,7 @@ func (e *encoder) calcStructArray(rv reflect.Value) (int, error) {
 		ret += def.Byte4
 	} else {
 		// not supported error
-		return 0, fmt.Errorf("not support this array length : %d", l)
+		return 0, fmt.Errorf("array length %d is %w", l, def.ErrUnsupportedLength)
 	}
 	return ret, nil
 }
@@ -142,7 +142,7 @@ func (e *encoder) calcStructMap(rv reflect.Value) (int, error) {
 		ret += def.Byte4
 	} else {
 		// not supported error
-		return 0, fmt.Errorf("not support this array length : %d", l)
+		return 0, fmt.Errorf("map length %d is %w", l, def.ErrUnsupportedLength)
 	}
 	return ret, nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/stream/decoding/complex.go

@@ -55,7 +55,7 @@ func (d *decoder) asComplex64(code byte, k reflect.Kind) (complex64, error) {
 
 	}
 
-	return complex(0, 0), fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
+	return complex(0, 0), d.errorTemplate(code, k)
 }
 
 func (d *decoder) asComplex128(code byte, k reflect.Kind) (complex128, error) {
@@ -94,7 +94,7 @@ func (d *decoder) asComplex128(code byte, k reflect.Kind) (complex128, error) {
 			return complex(0, 0), err
 		}
 		r := math.Float64frombits(binary.BigEndian.Uint64(rb))
-		
+
 		ib, err := d.readSize8()
 		if err != nil {
 			return complex(0, 0), err
@@ -104,5 +104,5 @@ func (d *decoder) asComplex128(code byte, k reflect.Kind) (complex128, error) {
 
 	}
 
-	return complex(0, 0), fmt.Errorf("should not reach this line!! code %x decoding %v", code, k)
+	return complex(0, 0), d.errorTemplate(code, k)
 }

vendor/github.com/shamaton/msgpack/v2/internal/stream/decoding/decoding.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"reflect"
 
+	"github.com/shamaton/msgpack/v2/def"
 	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
@@ -18,13 +19,12 @@ type decoder struct {
 // Decode analyzes the MessagePack-encoded data and stores
 // the result into the pointer of v.
 func Decode(r io.Reader, v interface{}, asArray bool) error {
-
 	if r == nil {
-		return fmt.Errorf("reader is nil")
+		return def.ErrNoData
 	}
 	rv := reflect.ValueOf(v)
 	if rv.Kind() != reflect.Ptr {
-		return fmt.Errorf("holder must set pointer value. but got: %t", v)
+		return fmt.Errorf("%w. v.(type): %T", def.ErrReceiverNotPointer, v)
 	}
 
 	rv = rv.Elem()
@@ -189,7 +189,7 @@ func (d *decoder) decodeWithCode(code byte, rv reflect.Value) error {
 				return err
 			}
 			if len(bs) > rv.Len() {
-				return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), len(bs))
+				return fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), len(bs), def.ErrNotMatchArrayElement)
 			}
 			for i, b := range bs {
 				rv.Index(i).SetUint(uint64(b))
@@ -203,7 +203,7 @@ func (d *decoder) decodeWithCode(code byte, rv reflect.Value) error {
 				return err
 			}
 			if l > rv.Len() {
-				return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
+				return fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), l, def.ErrNotMatchArrayElement)
 			}
 			bs, err := d.asStringByteByLength(l, k)
 			if err != nil {
@@ -222,7 +222,7 @@ func (d *decoder) decodeWithCode(code byte, rv reflect.Value) error {
 		}
 
 		if l > rv.Len() {
-			return fmt.Errorf("%v len is %d, but msgpack has %d elements", rv.Type(), rv.Len(), l)
+			return fmt.Errorf("%v len is %d, but msgpack has %d elements, %w", rv.Type(), rv.Len(), l, def.ErrNotMatchArrayElement)
 		}
 
 		// create array dynamically
@@ -314,11 +314,11 @@ func (d *decoder) decodeWithCode(code byte, rv reflect.Value) error {
 		}
 
 	default:
-		return fmt.Errorf("type(%v) is unsupported", rv.Kind())
+		return fmt.Errorf("%v is %w type", rv.Kind(), def.ErrUnsupportedType)
 	}
 	return nil
 }
 
 func (d *decoder) errorTemplate(code byte, k reflect.Kind) error {
-	return fmt.Errorf("msgpack : invalid code %x decoding %v", code, k)
+	return fmt.Errorf("%w %x decoding as %v", def.ErrCanNotDecode, code, k)
 }

vendor/github.com/shamaton/msgpack/v2/internal/stream/decoding/float.go

@@ -29,14 +29,14 @@ func (d *decoder) asFloat32WithCode(code byte, k reflect.Kind) (float32, error)
 	case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
 		v, err := d.asUintWithCode(code, k)
 		if err != nil {
-			break
+			return 0, err
 		}
 		return float32(v), nil
 
 	case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
 		v, err := d.asIntWithCode(code, k)
 		if err != nil {
-			break
+			return 0, err
 		}
 		return float32(v), nil
 
@@ -75,14 +75,14 @@ func (d *decoder) asFloat64WithCode(code byte, k reflect.Kind) (float64, error)
 	case d.isPositiveFixNum(code), code == def.Uint8, code == def.Uint16, code == def.Uint32, code == def.Uint64:
 		v, err := d.asUintWithCode(code, k)
 		if err != nil {
-			break
+			return 0, err
 		}
 		return float64(v), nil
 
 	case d.isNegativeFixNum(code), code == def.Int8, code == def.Int16, code == def.Int32, code == def.Int64:
 		v, err := d.asIntWithCode(code, k)
 		if err != nil {
-			break
+			return 0, err
 		}
 		return float64(v), nil
 

vendor/github.com/shamaton/msgpack/v2/internal/stream/decoding/interface.go

@@ -10,7 +10,7 @@ import (
 func (d *decoder) asInterface(k reflect.Kind) (interface{}, error) {
 	code, err := d.readSize1()
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 	return d.asInterfaceWithCode(code, k)
 }
@@ -133,7 +133,7 @@ func (d *decoder) asInterfaceWithCode(code byte, k reflect.Kind) (interface{}, e
 				return 0, err
 			}
 
-			if d.canSetAsMapKey(keyCode) != nil {
+			if err := d.canSetAsMapKey(keyCode); err != nil {
 				return nil, err
 			}
 			key, err := d.asInterfaceWithCode(keyCode, k)
@@ -169,9 +169,9 @@ func (d *decoder) asInterfaceWithCode(code byte, k reflect.Kind) (interface{}, e
 func (d *decoder) canSetAsMapKey(code byte) error {
 	switch {
 	case d.isFixSlice(code), code == def.Array16, code == def.Array32:
-		return fmt.Errorf("can not use slice code for map key/ code: %x", code)
+		return fmt.Errorf("%w. code: %x", def.ErrCanNotSetSliceAsMapKey, code)
 	case d.isFixMap(code), code == def.Map16, code == def.Map32:
-		return fmt.Errorf("can not use map code for map key/ code: %x", code)
+		return fmt.Errorf("%w. code: %x", def.ErrCanNotSetMapAsMapKey, code)
 	}
 	return nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/stream/decoding/struct.go

@@ -275,7 +275,7 @@ func (d *decoder) jumpOffset() error {
 	case code == def.Fixext16:
 		_, err = d.readSizeN(def.Byte1 + def.Byte16)
 		return err
-		
+
 	case code == def.Ext8:
 		b, err := d.readSize1()
 		if err != nil {

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/encoding.go

@@ -5,6 +5,7 @@ import (
 	"io"
 	"reflect"
 
+	"github.com/shamaton/msgpack/v2/def"
 	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
@@ -188,7 +189,7 @@ func (e *encoder) create(rv reflect.Value) error {
 	case reflect.Invalid:
 		return e.writeNil()
 	default:
-		return fmt.Errorf("type(%v) is unsupported", rv.Kind())
+		return fmt.Errorf("%v is %w type", rv.Kind(), def.ErrUnsupportedType)
 	}
 	return nil
 }

vendor/github.com/shamaton/msgpack/v2/internal/stream/encoding/struct.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"github.com/shamaton/msgpack/v2/def"
+	"github.com/shamaton/msgpack/v2/ext"
 	"github.com/shamaton/msgpack/v2/internal/common"
 )
 
@@ -24,7 +25,8 @@ func (e *encoder) getStructWriter(typ reflect.Type) structWriteFunc {
 	for i := range extCoders {
 		if extCoders[i].Type() == typ {
 			return func(rv reflect.Value) error {
-				return extCoders[i].Write(e.w, rv, e.buf)
+				w := ext.CreateStreamWriter(e.w, e.buf)
+				return extCoders[i].Write(w, rv)
 			}
 		}
 	}
@@ -39,7 +41,8 @@ func (e *encoder) writeStruct(rv reflect.Value) error {
 
 	for i := range extCoders {
 		if extCoders[i].Type() == rv.Type() {
-			return extCoders[i].Write(e.w, rv, e.buf)
+			w := ext.CreateStreamWriter(e.w, e.buf)
+			return extCoders[i].Write(w, rv)
 		}
 	}
 

vendor/github.com/shamaton/msgpack/v2/time/decode_stream.go

@@ -3,17 +3,16 @@ package time
 import (
 	"encoding/binary"
 	"fmt"
-	"github.com/shamaton/msgpack/v2/def"
-	"github.com/shamaton/msgpack/v2/ext"
 	"reflect"
 	"time"
+
+	"github.com/shamaton/msgpack/v2/def"
+	"github.com/shamaton/msgpack/v2/ext"
 )
 
 var StreamDecoder = new(timeStreamDecoder)
 
-type timeStreamDecoder struct {
-	ext.DecoderStreamCommon
-}
+type timeStreamDecoder struct{}
 
 var _ ext.StreamDecoder = (*timeStreamDecoder)(nil)
 

vendor/github.com/shamaton/msgpack/v2/time/encode_stream.go

@@ -1,8 +1,6 @@
 package time
 
 import (
-	"github.com/shamaton/msgpack/v2/internal/common"
-	"io"
 	"reflect"
 	"time"
 
@@ -12,9 +10,7 @@ import (
 
 var StreamEncoder = new(timeStreamEncoder)
 
-type timeStreamEncoder struct {
-	ext.StreamEncoderCommon
-}
+type timeStreamEncoder struct{}
 
 var _ ext.StreamEncoder = (*timeStreamEncoder)(nil)
 
@@ -26,50 +22,50 @@ func (timeStreamEncoder) Type() reflect.Type {
 	return typeOf
 }
 
-func (e timeStreamEncoder) Write(w io.Writer, value reflect.Value, buf *common.Buffer) error {
+func (e timeStreamEncoder) Write(w ext.StreamWriter, value reflect.Value) error {
 	t := value.Interface().(time.Time)
 
 	secs := uint64(t.Unix())
 	if secs>>34 == 0 {
 		data := uint64(t.Nanosecond())<<34 | secs
 		if data&0xffffffff00000000 == 0 {
-			if err := e.WriteByte1Int(w, def.Fixext4, buf); err != nil {
+			if err := w.WriteByte1Int(def.Fixext4); err != nil {
 				return err
 			}
-			if err := e.WriteByte1Int(w, def.TimeStamp, buf); err != nil {
+			if err := w.WriteByte1Int(def.TimeStamp); err != nil {
 				return err
 			}
-			if err := e.WriteByte4Uint64(w, data, buf); err != nil {
+			if err := w.WriteByte4Uint64(data); err != nil {
 				return err
 			}
 			return nil
 		}
 
-		if err := e.WriteByte1Int(w, def.Fixext8, buf); err != nil {
+		if err := w.WriteByte1Int(def.Fixext8); err != nil {
 			return err
 		}
-		if err := e.WriteByte1Int(w, def.TimeStamp, buf); err != nil {
+		if err := w.WriteByte1Int(def.TimeStamp); err != nil {
 			return err
 		}
-		if err := e.WriteByte8Uint64(w, data, buf); err != nil {
+		if err := w.WriteByte8Uint64(data); err != nil {
 			return err
 		}
 		return nil
 	}
 
-	if err := e.WriteByte1Int(w, def.Ext8, buf); err != nil {
+	if err := w.WriteByte1Int(def.Ext8); err != nil {
 		return err
 	}
-	if err := e.WriteByte1Int(w, 12, buf); err != nil {
+	if err := w.WriteByte1Int(12); err != nil {
 		return err
 	}
-	if err := e.WriteByte1Int(w, def.TimeStamp, buf); err != nil {
+	if err := w.WriteByte1Int(def.TimeStamp); err != nil {
 		return err
 	}
-	if err := e.WriteByte4Int(w, t.Nanosecond(), buf); err != nil {
+	if err := w.WriteByte4Int(t.Nanosecond()); err != nil {
 		return err
 	}
-	if err := e.WriteByte8Uint64(w, secs, buf); err != nil {
+	if err := w.WriteByte8Uint64(secs); err != nil {
 		return err
 	}
 	return nil

vendor/modules.txt

@@ -1808,7 +1808,7 @@ github.com/sergi/go-diff/diffmatchpatch
 # github.com/sethvargo/go-password v0.2.0
 ## explicit; go 1.14
 github.com/sethvargo/go-password/password
-# github.com/shamaton/msgpack/v2 v2.2.0
+# github.com/shamaton/msgpack/v2 v2.2.2
 ## explicit; go 1.20
 github.com/shamaton/msgpack/v2
 github.com/shamaton/msgpack/v2/def