Add chunk function with test cases

Implemented a utility function `Chunk` to split slices into chunks of specified sizes. Added comprehensive test cases for different slice and chunk size scenarios. Updated dependencies to include testing libraries such as `testify`.

Author: Mr Kiwi

go.mod

@@ -17,6 +17,7 @@ require (
 	github.com/pkg/errors v0.9.1
 	github.com/sanity-io/litter v1.5.5
 	github.com/spf13/cobra v1.8.1
+	github.com/stretchr/testify v1.9.0
 	github.com/surrealdb/surrealdb.go v0.2.1
 	go.uber.org/atomic v1.11.0
 	go.uber.org/fx v1.22.2
@@ -25,6 +26,7 @@ require (
 )
 
 require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/go-ini/ini v1.67.0 // indirect
 	github.com/goccy/go-json v0.10.3 // indirect
@@ -33,11 +35,13 @@ require (
 	github.com/klauspost/compress v1.17.10 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
 	github.com/minio/md5-simd v1.1.2 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/rs/xid v1.6.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	go.uber.org/dig v1.18.0 // indirect
 	golang.org/x/crypto v0.27.0 // indirect
 	golang.org/x/net v0.29.0 // indirect
 	golang.org/x/sys v0.25.0 // indirect
 	golang.org/x/text v0.18.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -87,6 +87,7 @@ golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
 golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

slices/chunk.go

@@ -0,0 +1,48 @@
+package slices
+
+// Chunk divides a slice of elements into multiple smaller slices, each of a specified size.
+//
+// The function takes a generic type parameter `T` which allows it to work with slices of any type.
+//
+// Parameters:
+//   - elements: A slice of elements of type `T` to be divided into chunks.
+//   - chunkSize: An integer representing the size of each chunk. If chunkSize is less than or equal to 0,
+//     an empty slice is returned.
+//
+// Returns:
+//   - A two-dimensional slice of type `T` where each inner slice is of length `chunkSize` (except possibly the last one).
+//     If chunkSize is less than or equal to 0, an empty slice of slices is returned. If the input slice is empty,
+//     an empty slice of slices is returned.
+//
+// Example usage:
+//
+//	chunks := Chunk([]int{1, 2, 3, 4, 5, 6}, 2)
+//	// chunks will be [][]int{{1, 2}, {3, 4}, {5, 6}}
+//
+//	chunks = Chunk([]int{1, 2, 3, 4, 5, 6}, 3)
+//	// chunks will be [][]int{{1, 2, 3}, {4, 5, 6}}
+//
+//	chunks = Chunk([]int{1, 2, 3, 4, 5, 6}, 0)
+//	// chunks will be [][]int{}
+//
+//	chunks = Chunk([]int{}, 3)
+//	// chunks will be [][]int{}
+func Chunk[T any](elements []T, chunkSize int) [][]T {
+	if chunkSize <= 0 {
+		return [][]T{}
+	}
+
+	capacity := (len(elements) + chunkSize - 1) / chunkSize
+	chunks := make([][]T, capacity)
+
+	for i, chunkIndex := 0, 0; i < len(elements); i += chunkSize {
+		end := i + chunkSize
+		isEndExceeding := end > len(elements)
+		if isEndExceeding {
+			end = len(elements)
+		}
+		chunks[chunkIndex] = elements[i:end]
+		chunkIndex++
+	}
+	return chunks
+}

slices/chunk_test.go

@@ -0,0 +1,49 @@
+package slices
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestChunk(t *testing.T) {
+	type testCase struct {
+		input     []int
+		chunkSize int
+		expected  [][]int
+	}
+
+	testCases := []testCase{
+		{
+			input:     []int{1, 2, 3, 4, 5, 6},
+			chunkSize: 2,
+			expected:  [][]int{{1, 2}, {3, 4}, {5, 6}},
+		},
+		{
+			input:     []int{1, 2, 3, 4, 5, 6},
+			chunkSize: 3,
+			expected:  [][]int{{1, 2, 3}, {4, 5, 6}},
+		},
+		{
+			input:     []int{1, 2},
+			chunkSize: 5,
+			expected:  [][]int{{1, 2}},
+		},
+		{
+			input:     []int{},
+			chunkSize: 3,
+			expected:  [][]int{},
+		},
+		{
+			input:     []int{1, 2, 3, 4, 5, 6},
+			chunkSize: 0,
+			expected:  [][]int{},
+		},
+	}
+
+	r := require.New(t)
+	for _, tc := range testCases {
+		result := Chunk(tc.input, tc.chunkSize)
+		r.Equal(tc.expected, result, "Chunk(%v, %d)", tc.input, tc.chunkSize)
+	}
+}