checkpoint: implemented a less complex looking moveAndShuffle function

internal/board/shuffle.go

@@ -1,48 +1,46 @@
 package board
 
-type shuffleDirection int
-
-const (
-	forwards shuffleDirection = iota
-	backwards
-)
-
 // moveAndShuffle creates a new list where the element specified at the index of the current
 // position is moved to the index of the target position. Elements within the range of the
 // old and new positions will then shuffle forwards or backwards in the list depending on the
 // direction of the move.
 // This is currently used to move specified columns forwards or backwards on the Kanban board.
 // When a column changes position the other columns shuffle forward or backwards as required.
-func moveAndShuffle(input []Status, currentIndex, targetIndex int) []Status {
-	var shuffle shuffleDirection
-
-	if targetIndex < currentIndex {
-		// affected elements will need to shuffle backwards if the focused
-		// element moves towards the beginning of the list...
-		shuffle = backwards
-	} else {
-		// ...or else the elements need to shuffle forwards if the focused
-		// element moves towards the end of the list.
-		shuffle = forwards
+func moveAndShuffle(input []Status, oldIndex, newIndex int) []Status {
+	if newIndex == oldIndex {
+		return input
 	}
 
 	output := make([]Status, len(input))
 
-	for ind := range input {
-		switch {
-		case (shuffle == backwards) && (ind < targetIndex || ind > currentIndex):
-			output[ind] = input[ind]
-		case (shuffle == backwards) && (ind == currentIndex):
-			output[targetIndex] = input[ind]
-		case (shuffle == backwards):
-			output[ind+1] = input[ind]
-		case (shuffle == forwards) && (ind < currentIndex || ind > targetIndex):
-			output[ind] = input[ind]
-		case (shuffle == forwards) && (ind == currentIndex):
-			output[targetIndex] = input[ind]
-		case (shuffle == forwards):
-			output[ind-1] = input[ind]
+	// copy the original slice and assign the target element to the
+	// new index.
+	copy(output, input)
+
+	output[newIndex] = input[oldIndex]
+
+	// shuffle the elements in range down the slice if the target element moves
+	// up the list.
+	if newIndex < oldIndex {
+		for index := newIndex; index <= oldIndex; index++ {
+			if index == oldIndex {
+				continue
 			}
+
+			output[index+1] = input[index]
+		}
+
+		return output
+	}
+
+	// shuffle the elements in range up the slice if the target element moves
+	// down the list.
+	for index := oldIndex; index <= newIndex; index++ {
+		if index == oldIndex {
+			continue
+		}
+
+		output[index-1] = input[index]
 	}
 
 	return output