Refactor emojiSequenceInexes

* Rename emojiSequenceIndexes to FindEmojiIndices
* move it into text util pacakge.
* improve unit test

Author: Bios-Marcel

ui/window.go

@@ -7,7 +7,6 @@ import (
 	"os/exec"
 	"strings"
 	"time"
-	"unicode"
 
 	"github.com/mattn/go-runewidth"
 	"github.com/mdp/qrterminal/v3"
@@ -1504,40 +1503,6 @@ func (window *Window) prepareMessage(targetChannel *discordgo.Channel, inputText
 	return message
 }
 
-// emojiSequenceIndexes will find all parts of a string (rune array) that
-// could potentially be emoji sequences and will return them backwards.
-// they'll be returned backwards in order to allow easily manipulating the
-// data without invalidating the following indexes accidentally.
-// Example:
-//     Hello :world:, what a :nice: day.
-// would result in
-//     []int{22,,27,6,12}
-func emojiSequenceIndexes(runes []rune) []int {
-	var sequencesBackwards []int
-	for i := len(runes) - 1; i >= 0; i-- {
-		if runes[i] == ':' {
-			for j := i - 1; j >= 0; j-- {
-				char := runes[j]
-				if char == ':' {
-					//Handle this ':' in the next iteration of the outer loop otherwise
-					if j != i-1 {
-						sequencesBackwards = append(sequencesBackwards, j, i)
-						i = j
-						break
-					} else {
-						break
-					}
-				} else if unicode.IsSpace(char) {
-					i = j
-					break
-				}
-			}
-		}
-	}
-
-	return sequencesBackwards
-}
-
 // mergeRuneSlices copies the passed rune arrays into a new rune array of the
 // correct size.
 func mergeRuneSlices(a, b, c []rune) *[]rune {
@@ -1556,7 +1521,7 @@ func mergeRuneSlices(a, b, c []rune) *[]rune {
 // For private channels, the channelGuild may be nil.
 func (window *Window) replaceEmojiSequences(channelGuild *discordgo.Guild, message string) string {
 	asRunes := []rune(message)
-	indexes := emojiSequenceIndexes(asRunes)
+	indexes := text.FindEmojiIndices(asRunes)
 INDEX_LOOP:
 	for i := 0; i < len(indexes); i += 2 {
 		startIndex := indexes[i]

ui/window_test.go

@@ -0,0 +1,37 @@
+package text
+
+import "unicode"
+
+// FindEmojiIndices will find all parts of a string (rune array) that
+// could potentially be emoji sequences and will return them backwards.
+// they'll be returned backwards in order to allow easily manipulating the
+// data without invalidating the following indexes accidentally.
+// Example:
+//     Hello :world:, what a :nice: day.
+// would result in
+//     []int{22,27,6,12}
+func FindEmojiIndices(runes []rune) []int {
+	var sequencesBackwards []int
+	for i := len(runes) - 1; i >= 0; i-- {
+		if runes[i] == ':' {
+			for j := i - 1; j >= 0; j-- {
+				char := runes[j]
+				if char == ':' {
+					//Handle this ':' in the next iteration of the outer loop otherwise
+					if j != i-1 {
+						sequencesBackwards = append(sequencesBackwards, j, i)
+						i = j
+						break
+					} else {
+						break
+					}
+				} else if unicode.IsSpace(char) {
+					i = j
+					break
+				}
+			}
+		}
+	}
+
+	return sequencesBackwards
+}

util/text/emoji.go

@@ -0,0 +1,106 @@
+package text
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestFindEmojiIndices(t *testing.T) {
+	type testcase struct {
+		name     string
+		input    string
+		expected []int
+	}
+	tests := []*testcase{
+		{
+			name:     "empty input",
+			input:    "",
+			expected: nil,
+		},
+		{
+			name:     "spaces",
+			input:    "         ",
+			expected: nil,
+		},
+		{
+			name:     "text with outer spaces",
+			input:    "     Numma Numma yay    ",
+			expected: nil,
+		},
+		{
+			name:     "just single emoji, but with spaces, therefore invaid",
+			input:    ":hel lo:",
+			expected: nil,
+		},
+		{
+			name:     "unclosed sequence",
+			input:    ":hello",
+			expected: nil,
+		},
+		{
+			name:     "unopened sequence",
+			input:    "hello:",
+			expected: nil,
+		},
+		{
+			name:     "tab inbetween sequence",
+			input:    ":hel\tlo:",
+			expected: nil,
+		},
+		{
+			name:     "newline inbetween sequence",
+			input:    ":hel\nlo:",
+			expected: nil,
+		},
+		{
+			name:     "just single emoji",
+			input:    ":hello:",
+			expected: []int{0, 6},
+		},
+		{
+			name:     "two emoji without anything inbetween",
+			input:    ":hello::world:",
+			expected: []int{7, 13, 0, 6},
+		},
+		{
+			name:     "two emoji withspaces inbetween",
+			input:    ":hello:  :world:",
+			expected: []int{9, 15, 0, 6},
+		},
+		{
+			name:     "two emoji with text inbetween",
+			input:    ":hello: Lorem Ipsum whatever :world:",
+			expected: []int{29, 35, 0, 6},
+		},
+		{
+			name:     "two valid emoji sequences with single unnecessary double colons in between",
+			input:    ":test:::lol:",
+			expected: []int{7, 11, 0, 5},
+		},
+		{
+			name:     "two valid emoji sequences with even amount of double colons in between",
+			input:    "::test:::lol:",
+			expected: []int{8, 12, 1, 6},
+		},
+		{
+			name:     "two valid emoji sequences with uneven amount of double colons in between",
+			input:    "::test::::lol:",
+			expected: []int{9, 13, 1, 6},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t2 *testing.T) {
+			result := FindEmojiIndices([]rune(test.input))
+
+			//We don't care whether it's empty or nil
+			if len(result) == 0 && len(test.expected) == 0 {
+				return
+			}
+
+			if !reflect.DeepEqual(result, test.expected) {
+				t2.Errorf("Got %v, but expected %v", result, test.expected)
+			}
+		})
+	}
+}