vendor: update all dependencies to latest versions

vendor/github.com/pengsrc/go-shared/buffer/bytes.go

@@ -0,0 +1,102 @@
+// Package buffer provides a thin wrapper around a byte slice. Unlike the
+// standard library's bytes.BytesBuffer, it supports a portion of the strconv
+// package's zero-allocation formatters.
+package buffer
+
+import (
+	"strconv"
+	"time"
+)
+
+// BytesBuffer is a thin wrapper around a byte slice. It's intended to be
+// pooled, so the only way to construct one is via a BytesBufferPool.
+type BytesBuffer struct {
+	bs   []byte
+	pool BytesBufferPool
+}
+
+// Free returns the BytesBuffer to its BytesBufferPool.
+// Callers must not retain references to the BytesBuffer after calling Free.
+func (b *BytesBuffer) Free() {
+	b.pool.put(b)
+}
+
+// Len returns the length of the underlying byte slice.
+func (b *BytesBuffer) Len() int {
+	return len(b.bs)
+}
+
+// Cap returns the capacity of the underlying byte slice.
+func (b *BytesBuffer) Cap() int {
+	return cap(b.bs)
+}
+
+// Bytes returns a mutable reference to the underlying byte slice.
+func (b *BytesBuffer) Bytes() []byte {
+	return b.bs
+}
+
+// String returns a string copy of the underlying byte slice.
+func (b *BytesBuffer) String() string {
+	return string(b.bs)
+}
+
+// Reset resets the underlying byte slice. Subsequent writes re-use the slice's
+// backing array.
+func (b *BytesBuffer) Reset() {
+	b.bs = b.bs[:0]
+}
+
+// Write implements io.Writer.
+func (b *BytesBuffer) Write(bs []byte) (int, error) {
+	b.bs = append(b.bs, bs...)
+	return len(bs), nil
+}
+
+// AppendByte writes a single byte to the BytesBuffer.
+func (b *BytesBuffer) AppendByte(v byte) {
+	b.bs = append(b.bs, v)
+}
+
+// AppendBytes writes bytes to the BytesBuffer.
+func (b *BytesBuffer) AppendBytes(bs []byte) {
+	b.bs = append(b.bs, bs...)
+}
+
+// AppendString writes a string to the BytesBuffer.
+func (b *BytesBuffer) AppendString(s string) {
+	b.bs = append(b.bs, s...)
+}
+
+// AppendInt appends an integer to the underlying buffer (assuming base 10).
+func (b *BytesBuffer) AppendInt(i int64) {
+	b.bs = strconv.AppendInt(b.bs, i, 10)
+}
+
+// AppendUint appends an unsigned integer to the underlying buffer (assuming
+// base 10).
+func (b *BytesBuffer) AppendUint(i uint64) {
+	b.bs = strconv.AppendUint(b.bs, i, 10)
+}
+
+// AppendFloat appends a float to the underlying buffer. It doesn't quote NaN
+// or +/- Inf.
+func (b *BytesBuffer) AppendFloat(f float64, bitSize int) {
+	b.bs = strconv.AppendFloat(b.bs, f, 'f', -1, bitSize)
+}
+
+// AppendBool appends a bool to the underlying buffer.
+func (b *BytesBuffer) AppendBool(v bool) {
+	b.bs = strconv.AppendBool(b.bs, v)
+}
+
+// AppendTime appends a time to the underlying buffer.
+func (b *BytesBuffer) AppendTime(t time.Time, format string) {
+	if format == "" {
+		b.bs = strconv.AppendInt(b.bs, t.Unix(), 10)
+	} else {
+		b.bs = t.AppendFormat(b.bs, format)
+	}
+}
+
+const defaultSize = 1024 // Create 1 KiB buffers by default

vendor/github.com/pengsrc/go-shared/buffer/bytes_pool.go

@@ -0,0 +1,39 @@
+package buffer
+
+import "sync"
+
+// A BytesBufferPool is a type-safe wrapper around a sync.BytesBufferPool.
+type BytesBufferPool struct {
+	p *sync.Pool
+}
+
+// NewBytesPool constructs a new BytesBufferPool.
+func NewBytesPool() BytesBufferPool {
+	return BytesBufferPool{
+		p: &sync.Pool{
+			New: func() interface{} {
+				return &BytesBuffer{bs: make([]byte, 0, defaultSize)}
+			},
+		},
+	}
+}
+
+// Get retrieves a BytesBuffer from the pool, creating one if necessary.
+func (p BytesBufferPool) Get() *BytesBuffer {
+	buf := p.p.Get().(*BytesBuffer)
+	buf.Reset()
+	buf.pool = p
+	return buf
+}
+
+func (p BytesBufferPool) put(buf *BytesBuffer) {
+	p.p.Put(buf)
+}
+
+// GlobalBytesPool returns the global buffer pool.
+func GlobalBytesPool() *BytesBufferPool {
+	return &bytesPool
+}
+
+// bytesPool is a pool of buffer bytes.
+var bytesPool = NewBytesPool()

vendor/github.com/pengsrc/go-shared/buffer/bytes_pool_test.go

@@ -0,0 +1,36 @@
+package buffer
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuffers(t *testing.T) {
+	const dummyData = "dummy data"
+	p := NewBytesPool()
+
+	var wg sync.WaitGroup
+	for g := 0; g < 10; g++ {
+		wg.Add(1)
+		go func() {
+			for i := 0; i < 100; i++ {
+				buf := p.Get()
+				assert.Zero(t, buf.Len(), "Expected truncated buffer")
+				assert.NotZero(t, buf.Cap(), "Expected non-zero capacity")
+
+				buf.AppendString(dummyData)
+				assert.Equal(t, buf.Len(), len(dummyData), "Expected buffer to contain dummy data")
+
+				buf.Free()
+			}
+			wg.Done()
+		}()
+	}
+	wg.Wait()
+}
+
+func TestGlobalBytesPool(t *testing.T) {
+	assert.NotNil(t, GlobalBytesPool())
+}

vendor/github.com/pengsrc/go-shared/buffer/bytes_test.go

@@ -0,0 +1,76 @@
+package buffer
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/pengsrc/go-shared/convert"
+)
+
+func TestBufferWrites(t *testing.T) {
+	buf := NewBytesPool().Get()
+
+	tests := []struct {
+		desc string
+		f    func()
+		want string
+	}{
+		{"AppendByte", func() { buf.AppendByte('v') }, "v"},
+		{"AppendBytes", func() { buf.AppendBytes([]byte{'a', 'b', 'c'}) }, "abc"},
+		{"AppendString", func() { buf.AppendString("foo") }, "foo"},
+		{"AppendIntPositive", func() { buf.AppendInt(42) }, "42"},
+		{"AppendIntNegative", func() { buf.AppendInt(-42) }, "-42"},
+		{"AppendUint", func() { buf.AppendUint(42) }, "42"},
+		{"AppendBool", func() { buf.AppendBool(true) }, "true"},
+		{"AppendFloat64", func() { buf.AppendFloat(3.14, 64) }, "3.14"},
+		// Intentionally introduce some floating-point error.
+		{"AppendFloat32", func() { buf.AppendFloat(float64(float32(3.14)), 32) }, "3.14"},
+		{"AppendTime", func() { buf.AppendTime(time.Time{}, convert.ISO8601Milli) }, "0001-01-01T00:00:00.000Z"},
+		{"AppendWrite", func() { buf.Write([]byte("foo")) }, "foo"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			buf.Reset()
+			tt.f()
+			assert.Equal(t, tt.want, buf.String(), "Unexpected buffer.String().")
+			assert.Equal(t, tt.want, string(buf.Bytes()), "Unexpected string(buffer.Bytes()).")
+			assert.Equal(t, len(tt.want), buf.Len(), "Unexpected buffer length.")
+			// We're not writing more than a kilobyte in tests.
+			assert.Equal(t, defaultSize, buf.Cap(), "Expected buffer capacity to remain constant.")
+		})
+	}
+}
+
+func BenchmarkBuffers(b *testing.B) {
+	// Because we use the strconv.AppendFoo functions so liberally, we can't
+	// use the standard library's bytes.Buffer anyways (without incurring a
+	// bunch of extra allocations). Nevertheless, let's make sure that we're
+	// not losing any precious nanoseconds.
+	str := strings.Repeat("a", 1024)
+	slice := make([]byte, 1024)
+	buf := bytes.NewBuffer(slice)
+	custom := NewBytesPool().Get()
+	b.Run("ByteSlice", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			slice = append(slice, str...)
+			slice = slice[:0]
+		}
+	})
+	b.Run("BytesBuffer", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			buf.WriteString(str)
+			buf.Reset()
+		}
+	})
+	b.Run("CustomBuffer", func(b *testing.B) {
+		for i := 0; i < b.N; i++ {
+			custom.AppendString(str)
+			custom.Reset()
+		}
+	})
+}