Fixes bug with suggestion case learning (#584) (#585)

Author: urikdev

app/src/main/java/com/urik/keyboard/UrikInputMethodService.kt

@@ -1820,7 +1820,7 @@ class UrikInputMethodService :
                                     try {
                                         autoCapitalizePronounI()
                                         learnWordAndInvalidateCache(
-                                            wordState.normalizedBuffer,
+                                            wordState.buffer,
                                             InputMethod.TYPED,
                                         )
                                         currentInputConnection?.finishComposingText()
@@ -1841,7 +1841,7 @@ class UrikInputMethodService :
                                     return@launch
                                 } else {
                                     spellConfirmationState = SpellConfirmationState.AWAITING_CONFIRMATION
-                                    pendingWordForLearning = wordState.normalizedBuffer
+                                    pendingWordForLearning = wordState.buffer
                                     highlightCurrentWord()
 
                                     val suggestions = textInputProcessor.getSuggestions(wordState.normalizedBuffer)
@@ -1954,7 +1954,7 @@ class UrikInputMethodService :
                                 if (result.shouldHighlight) {
                                     spellConfirmationState =
                                         SpellConfirmationState.AWAITING_CONFIRMATION
-                                    pendingWordForLearning = result.wordState.normalizedBuffer
+                                    pendingWordForLearning = result.wordState.buffer
                                     highlightCurrentWord()
                                 }
                             }
@@ -2746,7 +2746,7 @@ class UrikInputMethodService :
                                 textInputProcessor.getSuggestions(wordState.normalizedBuffer)
 
                             spellConfirmationState = SpellConfirmationState.AWAITING_CONFIRMATION
-                            pendingWordForLearning = wordState.normalizedBuffer
+                            pendingWordForLearning = wordState.buffer
 
                             highlightCurrentWord()
                             val displaySuggestions = applyCapitalizationToSuggestions(suggestions, isCurrentWordAtSentenceStart)

app/src/main/java/com/urik/keyboard/data/database/LearnedWord.kt

@@ -54,6 +54,30 @@ data class LearnedWord(
     @ColumnInfo(name = "last_used")
     val lastUsed: Long = System.currentTimeMillis(),
 ) {
+    /**
+     * Returns new instance with incremented frequency and updated timestamp.
+     */
+    fun incrementFrequency(): LearnedWord =
+        copy(
+            frequency = frequency + 1,
+            lastUsed = System.currentTimeMillis(),
+        )
+
+    /**
+     * Increments frequency and promotes casing when the new variant
+     * demonstrates higher intentionality than the stored form.
+     *
+     */
+    fun updateCasingIfPreferred(newWord: String): LearnedWord {
+        val updated = incrementFrequency()
+        if (word == newWord) return updated
+        return if (casingIntentScore(newWord) > casingIntentScore(word)) {
+            updated.copy(word = newWord)
+        } else {
+            updated
+        }
+    }
+
     companion object {
         /**
          * Creates LearnedWord with calculated grapheme count.
@@ -82,9 +106,6 @@ data class LearnedWord(
                 lastUsed = lastUsed,
             )
 
-        /**
-         * Calculates visible character count using ICU4J grapheme clusters
-         */
         fun calculateGraphemeCount(text: String): Int {
             val iterator = BreakIterator.getCharacterInstance()
             iterator.setText(text)
@@ -94,16 +115,21 @@ data class LearnedWord(
             }
             return count
         }
-    }
 
-    /**
-     * Returns new instance with incremented frequency and updated timestamp.
-     */
-    fun incrementFrequency(): LearnedWord =
-        copy(
-            frequency = frequency + 1,
-            lastUsed = System.currentTimeMillis(),
-        )
+        fun casingIntentScore(word: String): Int {
+            if (word.isEmpty()) return 0
+            val hasUpper = word.any { it.isUpperCase() }
+            val hasLower = word.any { it.isLowerCase() }
+            return when {
+                !hasUpper -> 0
+                !hasLower && word.length <= 3 -> 3
+                !hasLower -> 1
+                word.drop(1).any { it.isUpperCase() } -> 4
+                word[0].isUpperCase() -> 2
+                else -> 0
+            }
+        }
+    }
 }
 
 /**

app/src/main/java/com/urik/keyboard/data/database/LearnedWordDao.kt

@@ -183,17 +183,18 @@ interface LearnedWordDao {
     suspend fun upsertWord(word: LearnedWord): Long
 
     /**
-     * Learns word with frequency tracking and FTS synchronization.
+     * Learns word with frequency tracking and casing promotion.
      *
-     * If word exists: increments frequency, updates timestamp
-     * If new: inserts with frequency=1
+     * If word exists: increments frequency, promotes casing when the new
+     * variant has higher intentionality (e.g., "iPhone" over "iphone").
+     * If new: inserts with frequency=1.
      * FTS table automatically synchronized in transaction.
      */
     @Transaction
     suspend fun learnWord(word: LearnedWord) {
         val existing = findExactWord(word.languageTag, word.wordNormalized)
         if (existing != null) {
-            val updated = existing.incrementFrequency()
+            val updated = existing.updateCasingIfPreferred(word.word)
             updateWord(updated)
         } else {
             insertWord(word)
@@ -274,8 +275,15 @@ interface LearnedWordDao {
     suspend fun importWordWithMerge(word: LearnedWord) {
         val existing = findExactWord(word.languageTag, word.wordNormalized)
         if (existing != null) {
+            val preferredWord =
+                if (LearnedWord.casingIntentScore(word.word) > LearnedWord.casingIntentScore(existing.word)) {
+                    word.word
+                } else {
+                    existing.word
+                }
             val merged =
                 existing.copy(
+                    word = preferredWord,
                     frequency = existing.frequency + word.frequency,
                     lastUsed = maxOf(existing.lastUsed, word.lastUsed),
                 )

app/src/test/java/com/urik/keyboard/data/database/LearnedWordDaoTest.kt

@@ -420,6 +420,220 @@ class LearnedWordDaoTest {
             assertEquals(1, swipedCount)
         }
 
+    @Test
+    fun `learnWord promotes camelCase over lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("iphone", "iphone", "en"))
+            dao.learnWord(createTestWord("iPhone", "iphone", "en"))
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+            assertEquals(2, retrieved?.frequency)
+        }
+
+    @Test
+    fun `learnWord promotes title case over lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("maryland", "maryland", "en"))
+            dao.learnWord(createTestWord("Maryland", "maryland", "en"))
+
+            val retrieved = dao.findExactWord("en", "maryland")
+            assertEquals("Maryland", retrieved?.word)
+            assertEquals(2, retrieved?.frequency)
+        }
+
+    @Test
+    fun `learnWord does not demote camelCase to lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("iPhone", "iphone", "en"))
+            dao.learnWord(createTestWord("iphone", "iphone", "en"))
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+            assertEquals(2, retrieved?.frequency)
+        }
+
+    @Test
+    fun `learnWord does not demote McLaren to lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("McLaren", "mclaren", "en"))
+            repeat(5) {
+                dao.learnWord(createTestWord("mclaren", "mclaren", "en"))
+            }
+
+            val retrieved = dao.findExactWord("en", "mclaren")
+            assertEquals("McLaren", retrieved?.word)
+            assertEquals(6, retrieved?.frequency)
+        }
+
+    @Test
+    fun `learnWord promotes short acronym over lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("api", "api", "en"))
+            dao.learnWord(createTestWord("API", "api", "en"))
+
+            val retrieved = dao.findExactWord("en", "api")
+            assertEquals("API", retrieved?.word)
+        }
+
+    @Test
+    fun `learnWord promotes long ALL CAPS over lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("guhh", "guhh", "en"))
+            dao.learnWord(createTestWord("GUHH", "guhh", "en"))
+
+            val retrieved = dao.findExactWord("en", "guhh")
+            assertEquals("GUHH", retrieved?.word)
+        }
+
+    @Test
+    fun `learnWord does not demote ALL CAPS to lowercase`() =
+        runTest {
+            dao.learnWord(createTestWord("NASA", "nasa", "en"))
+            dao.learnWord(createTestWord("nasa", "nasa", "en"))
+
+            val retrieved = dao.findExactWord("en", "nasa")
+            assertEquals("NASA", retrieved?.word)
+        }
+
+    @Test
+    fun `learnWord promotes camelCase over ALL CAPS`() =
+        runTest {
+            dao.learnWord(createTestWord("IPHONE", "iphone", "en"))
+            dao.learnWord(createTestWord("iPhone", "iphone", "en"))
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+        }
+
+    @Test
+    fun `learnWord promotes camelCase over title case`() =
+        runTest {
+            dao.learnWord(createTestWord("Iphone", "iphone", "en"))
+            dao.learnWord(createTestWord("iPhone", "iphone", "en"))
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+        }
+
+    @Test
+    fun `learnWord keeps same casing stable across repeated learns`() =
+        runTest {
+            repeat(10) {
+                dao.learnWord(createTestWord("hello", "hello", "en"))
+            }
+
+            val retrieved = dao.findExactWord("en", "hello")
+            assertEquals("hello", retrieved?.word)
+            assertEquals(10, retrieved?.frequency)
+        }
+
+    @Test
+    fun `importWordWithMerge promotes camelCase casing`() =
+        runTest {
+            dao.insertWord(createTestWord("iphone", "iphone", "en", frequency = 50))
+
+            val imported = createTestWord("iPhone", "iphone", "en", frequency = 3)
+            dao.importWordWithMerge(imported)
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+            assertEquals(53, retrieved?.frequency)
+        }
+
+    @Test
+    fun `casingIntentScore scores lowercase as 0`() {
+        assertEquals(0, LearnedWord.casingIntentScore("hello"))
+        assertEquals(0, LearnedWord.casingIntentScore("iphone"))
+        assertEquals(0, LearnedWord.casingIntentScore("fasty"))
+    }
+
+    @Test
+    fun `casingIntentScore scores long ALL CAPS as 1`() {
+        assertEquals(1, LearnedWord.casingIntentScore("HELLO"))
+        assertEquals(1, LearnedWord.casingIntentScore("GUHH"))
+        assertEquals(1, LearnedWord.casingIntentScore("FASTY"))
+    }
+
+    @Test
+    fun `casingIntentScore scores title case as 2`() {
+        assertEquals(2, LearnedWord.casingIntentScore("Maryland"))
+        assertEquals(2, LearnedWord.casingIntentScore("Google"))
+        assertEquals(2, LearnedWord.casingIntentScore("Hello"))
+    }
+
+    @Test
+    fun `casingIntentScore scores short acronym as 3`() {
+        assertEquals(3, LearnedWord.casingIntentScore("API"))
+        assertEquals(3, LearnedWord.casingIntentScore("US"))
+        assertEquals(3, LearnedWord.casingIntentScore("UK"))
+    }
+
+    @Test
+    fun `casingIntentScore scores mixed case as 4`() {
+        assertEquals(4, LearnedWord.casingIntentScore("iPhone"))
+        assertEquals(4, LearnedWord.casingIntentScore("McLaren"))
+        assertEquals(4, LearnedWord.casingIntentScore("myAPI"))
+        assertEquals(4, LearnedWord.casingIntentScore("DeepMind"))
+    }
+
+    @Test
+    fun `casingIntentScore returns 0 for empty string`() {
+        assertEquals(0, LearnedWord.casingIntentScore(""))
+    }
+
+    @Test
+    fun `casingIntentScore hierarchy mixed beats title beats lowercase`() {
+        val lowercase = LearnedWord.casingIntentScore("iphone")
+        val allCaps = LearnedWord.casingIntentScore("IPHONE")
+        val titleCase = LearnedWord.casingIntentScore("Iphone")
+        val mixedCase = LearnedWord.casingIntentScore("iPhone")
+
+        assertTrue(mixedCase > titleCase)
+        assertTrue(titleCase > allCaps)
+        assertTrue(allCaps > lowercase)
+    }
+
+    @Test
+    fun `updateCasingIfPreferred promotes to higher intent`() {
+        val word = createTestWord("iphone", "iphone", "en", frequency = 10)
+        val updated = word.updateCasingIfPreferred("iPhone")
+
+        assertEquals("iPhone", updated.word)
+        assertEquals(11, updated.frequency)
+    }
+
+    @Test
+    fun `updateCasingIfPreferred does not demote to lower intent`() {
+        val word = createTestWord("iPhone", "iphone", "en", frequency = 10)
+        val updated = word.updateCasingIfPreferred("iphone")
+
+        assertEquals("iPhone", updated.word)
+        assertEquals(11, updated.frequency)
+    }
+
+    @Test
+    fun `updateCasingIfPreferred keeps same casing`() {
+        val word = createTestWord("iPhone", "iphone", "en", frequency = 10)
+        val updated = word.updateCasingIfPreferred("iPhone")
+
+        assertEquals("iPhone", updated.word)
+        assertEquals(11, updated.frequency)
+    }
+
+    @Test
+    fun `importWordWithMerge does not demote camelCase`() =
+        runTest {
+            dao.insertWord(createTestWord("iPhone", "iphone", "en", frequency = 50))
+
+            val imported = createTestWord("iphone", "iphone", "en", frequency = 100)
+            dao.importWordWithMerge(imported)
+
+            val retrieved = dao.findExactWord("en", "iphone")
+            assertEquals("iPhone", retrieved?.word)
+            assertEquals(150, retrieved?.frequency)
+        }
+
     /**
      * Creates test word with defaults for frequency, source, and timestamps.
      */