feat: fix Vietnamese Telex input transformation

- Change iteration from backwards to forward (longest-match-first)
- Add case-insensitive matching for Telex rules
- Add case preservation (Aw→Ă, aw→ă, Ow→Ơ, ow→ơ)
- Add Vietnamese chars (ă, ư, ơ) to keyboard popups
- Fix test helpers to use case-insensitive matching
- Add missing 'ww→ư' rule to test suite
- Add 4 new tests for case preservation verification

Author: naoNao89

app/src/main/kotlin/org/fossify/keyboard/services/SimpleKeyboardIME.kt

@@ -383,14 +383,19 @@ class SimpleKeyboardIME : InputMethodService(), OnKeyboardActionListener, Shared
                             } else 0
                             if (lastIndexEmpty >= 0) {
                                 val word = fullText.subSequence(lastIndexEmpty, fullText.length).trim().toString()
-                                val wordChars = word.toCharArray()
-                                val predictWord = StringBuilder()
-                                for (char in wordChars.size - 1 downTo 0) {
-                                    predictWord.append(wordChars[char])
-                                    val shouldChangeText = predictWord.reverse().toString()
-                                    if (cachedVNTelexData.containsKey(shouldChangeText)) {
-                                        inputConnection.setComposingRegion(fullText.length - shouldChangeText.length, fullText.length)
-                                        inputConnection.setComposingText(cachedVNTelexData[shouldChangeText], fullText.length)
+                                for (i in word.indices) {
+                                    val partialWord = word.substring(i, word.length)
+                                    val partialWordLower = partialWord.lowercase()
+                                    if (cachedVNTelexData.containsKey(partialWordLower)) {
+                                        val replacement = cachedVNTelexData[partialWordLower]!!
+                                        // Preserve case: if first char is uppercase, capitalize replacement
+                                        val finalReplacement = if (partialWord.firstOrNull()?.isUpperCase() == true && replacement.isNotEmpty()) {
+                                            replacement.replaceFirstChar { it.uppercase() }
+                                        } else {
+                                            replacement
+                                        }
+                                        inputConnection.setComposingRegion(fullText.length - partialWordLower.length, fullText.length)
+                                        inputConnection.setComposingText(finalReplacement, fullText.length)
                                         inputConnection.setComposingRegion(fullText.length, fullText.length)
                                         return
                                     }

app/src/main/res/xml/keys_letters_english_qwerty.xml

@@ -43,7 +43,7 @@
             app:topSmallNumber="1" />
         <Key
             app:keyLabel="w"
-            app:popupCharacters="2"
+            app:popupCharacters="2ư"
             app:popupKeyboard="@xml/keyboard_popup_template"
             app:topSmallNumber="2" />
         <Key
@@ -78,7 +78,7 @@
             app:topSmallNumber="8" />
         <Key
             app:keyLabel="o"
-            app:popupCharacters="őöøóôòõ9ō"
+            app:popupCharacters="őöøóôòõ9ōơ"
             app:popupKeyboard="@xml/keyboard_popup_template"
             app:topSmallNumber="9" />
         <Key
@@ -93,7 +93,7 @@
             app:horizontalGap="5%"
             app:keyEdgeFlags="left"
             app:keyLabel="a"
-            app:popupCharacters="áàâãäåāæą"
+            app:popupCharacters="áàâãäåāæąă"
             app:popupKeyboard="@xml/keyboard_popup_template" />
         <Key
             app:keyLabel="s"

app/src/test/kotlin/org/fossify/keyboard/services/VietnameseTelexTest.kt

@@ -12,6 +12,7 @@ class VietnameseTelexTest {
     fun setup() {
         telexRules = hashMapOf(
             "w" to "ư",
+            "ww" to "ư",
             "a" to "ă",
             "aw" to "ă",
             "aa" to "â",
@@ -63,7 +64,7 @@ class VietnameseTelexTest {
     fun testDoubleWTransformation() {
         val input = "ww"
         val shortestFirstResult = applyRulesShortestFirst(input)
-        assertEquals("Wư", shortestFirstResult)
+        assertEquals("wư", shortestFirstResult)
 
         val longestFirstResult = applyRulesLongestFirst(input)
         assertEquals("ư", longestFirstResult)
@@ -122,6 +123,34 @@ class VietnameseTelexTest {
         assertEquals("O ư", result)
     }
 
+    @Test
+    fun testUppercaseCasePreservation_Aw() {
+        val input = "Aw"
+        val result = applyRulesWithCasePreservation(input)
+        assertEquals("Ă", result)
+    }
+
+    @Test
+    fun testLowercaseCasePreservation_aw() {
+        val input = "aw"
+        val result = applyRulesWithCasePreservation(input)
+        assertEquals("ă", result)
+    }
+
+    @Test
+    fun testUppercaseCasePreservation_Ow() {
+        val input = "Ow"
+        val result = applyRulesWithCasePreservation(input)
+        assertEquals("Ơ", result)
+    }
+
+    @Test
+    fun testLowercaseCasePreservation_ow() {
+        val input = "ow"
+        val result = applyRulesWithCasePreservation(input)
+        assertEquals("ơ", result)
+    }
+
     /**
      * Helper function that applies transformation rules checking shortest patterns first.
      * This demonstrates incorrect behavior when shorter patterns match before longer ones.
@@ -133,10 +162,11 @@ class VietnameseTelexTest {
         for (char in wordChars.size - 1 downTo 0) {
             predictWord.append(wordChars[char])
             val shouldChangeText = predictWord.reverse().toString()
+            val shouldChangeTextLower = shouldChangeText.lowercase()
 
-            if (telexRules.containsKey(shouldChangeText)) {
+            if (telexRules.containsKey(shouldChangeTextLower)) {
                 val prefix = word.substring(0, word.length - shouldChangeText.length)
-                return prefix + telexRules[shouldChangeText]
+                return prefix + telexRules[shouldChangeTextLower]
             }
 
             predictWord.reverse()
@@ -152,15 +182,39 @@ class VietnameseTelexTest {
     private fun applyRulesLongestFirst(word: String): String {
         for (length in word.length downTo 1) {
             val suffix = word.substring(word.length - length)
-            if (telexRules.containsKey(suffix)) {
+            val suffixLower = suffix.lowercase()
+            if (telexRules.containsKey(suffixLower)) {
                 val prefix = word.substring(0, word.length - length)
-                return prefix + telexRules[suffix]!!
+                return prefix + telexRules[suffixLower]!!
             }
         }
 
         return word
     }
 
+    /**
+     * Helper function that applies transformation rules with case preservation.
+     * Matches case-insensitively but preserves the original case in output.
+     */
+    private fun applyRulesWithCasePreservation(word: String): String {
+        for (length in word.length downTo 1) {
+            val suffix = word.substring(word.length - length)
+            val suffixLower = suffix.lowercase()
+            if (telexRules.containsKey(suffixLower)) {
+                val prefix = word.substring(0, word.length - length)
+                val replacement = telexRules[suffixLower]!!
+                // Preserve case: if first char is uppercase, capitalize replacement
+                val finalReplacement = if (suffix.firstOrNull()?.isUpperCase() == true && replacement.isNotEmpty()) {
+                    replacement.replaceFirstChar { it.uppercase() }
+                } else {
+                    replacement
+                }
+                return prefix + finalReplacement
+            }
+        }
+        return word
+    }
+
     /**
      * Helper function that applies rules with case-sensitive matching.
      * Mixed-case input won't match lowercase rules.