From 06ee04e0cd0ef5e2e9f0381df31a6a4cb691dc44 Mon Sep 17 00:00:00 2001 From: LeanBitLab Date: Thu, 19 Nov 2026 05:02:23 +0530 Subject: [PATCH] fix(dict): never blacklist main dictionary words when removing a suggestion (#861) Blacklist matching ignores case, but removeWord only checked the lowercase form against the main dictionary, so removing "I'm" blacklisted "i'm". Check all case variants and decide once across dictionary groups, so a word of one language is not blacklisted through another language's group. --- .../latin/DictionaryFacilitatorImpl.kt | 24 +++++++++++++----- .../keyboard/latin/DictionaryGroupTest.kt | 25 +++++++++++++++++++ 2 files changed, 43 insertions(+), 6 deletions(-) diff --git a/app/src/main/java/helium314/keyboard/latin/DictionaryFacilitatorImpl.kt b/app/src/main/java/helium314/keyboard/latin/DictionaryFacilitatorImpl.kt index 09e3990b3..0a05a28ee 100644 --- a/app/src/main/java/helium314/keyboard/latin/DictionaryFacilitatorImpl.kt +++ b/app/src/main/java/helium314/keyboard/latin/DictionaryFacilitatorImpl.kt @@ -987,8 +987,11 @@ class DictionaryFacilitatorImpl : DictionaryFacilitator { override fun removeWord(word: String) { sessionWordBoost?.removeWord(word) + // Decide once for all groups: blacklist matching ignores case and checks every group, + // so a word of one language must not get blacklisted through another language's group. + val isMainDictWord = dictionaryGroups.any { it.isMainDictWord(word) } for (dictionaryGroup in dictionaryGroups) { - dictionaryGroup.removeWord(word) + dictionaryGroup.removeWord(word, isMainDictWord) } } @@ -1163,11 +1166,20 @@ private class DictionaryGroup( // concurrent blacklist operations could then run without mutual exclusion. private val blacklistLock = Any() - /** Removes a word from all dictionaries in this group. If the word is in a read-only dictionary, it is blacklisted. */ - fun removeWord(word: String) { + /** + * Whether any case variant of [word] is in the main dictionary. Blacklist matching ignores case, + * so "i'm" must count as a main dictionary word when the dictionary only has "I'm". + */ + fun isMainDictWord(word: String): Boolean { + val mainDict = getDict(Dictionary.TYPE_MAIN) ?: return false + val lowercase = word.lowercase(locale) + return setOf(word, lowercase, StringUtils.capitalizeFirstCodePoint(lowercase, locale), word.uppercase(locale)) + .any { mainDict.isValidWord(it) } + } + + /** Removes a word from all dictionaries in this group. Unless [isMainDictWord], it is also blacklisted. */ + fun removeWord(word: String, isMainDictWord: Boolean = isMainDictWord(word)) { val lowercase = word.lowercase(locale) - val mainDict = getDict(Dictionary.TYPE_MAIN) - val isLowercaseInMainDict = mainDict?.isValidWord(lowercase) == true // Remove from user history getSubDict(Dictionary.TYPE_USER_HISTORY)?.removeUnigramEntryDynamically(word) @@ -1202,7 +1214,7 @@ private class DictionaryGroup( // Only add to blacklist if the word is NOT a standard valid word in the main system dictionary. // Never blacklist core dictionary words (e.g. "in", "is", "me", "ok") when deleting suggestions. - if (!isLowercaseInMainDict) { + if (!isMainDictWord) { addToBlacklist(lowercase) } else { // If it's a main dict word, un-blacklist it in case it was previously mistakenly blacklisted diff --git a/app/src/test/java/helium314/keyboard/latin/DictionaryGroupTest.kt b/app/src/test/java/helium314/keyboard/latin/DictionaryGroupTest.kt index a9ac2a242..8f63db849 100644 --- a/app/src/test/java/helium314/keyboard/latin/DictionaryGroupTest.kt +++ b/app/src/test/java/helium314/keyboard/latin/DictionaryGroupTest.kt @@ -10,6 +10,7 @@ import org.junit.Test import org.mockito.Mockito.mock import org.mockito.Mockito.verify import org.mockito.Mockito.never +import org.mockito.Mockito.`when` import java.util.Locale class DictionaryGroupTest { @@ -113,4 +114,28 @@ class DictionaryGroupTest { assertTrue(isBlacklistedMethod.invoke(instance, "superbad") as Boolean) assertFalse(isBlacklistedMethod.invoke(instance, "goodword") as Boolean) } + + @Test + fun testRemoveWord_DoesNotBlacklistCapitalizedMainDictWord() { + val dictGroupClass = Class.forName("helium314.keyboard.latin.DictionaryGroup") + val constructor = dictGroupClass.declaredConstructors.first { it.parameterCount == 4 } + constructor.isAccessible = true + + // The main dictionary only has the capitalized form, like "I'm" in English. + val mockMainDict = mock(Dictionary::class.java) + `when`(mockMainDict.isValidWord("I'm")).thenReturn(true) + val instance = constructor.newInstance(Locale.ENGLISH, mockMainDict, emptyMap(), null) + val isMainDictWordMethod = dictGroupClass.getDeclaredMethod("isMainDictWord", String::class.java) + val removeWordMethod = dictGroupClass.getDeclaredMethod("removeWord", String::class.java, Boolean::class.javaPrimitiveType) + val isBlacklistedMethod = dictGroupClass.getDeclaredMethod("isBlacklisted", String::class.java) + listOf(isMainDictWordMethod, removeWordMethod, isBlacklistedMethod).forEach { it.isAccessible = true } + + for (word in listOf("I'm", "i'm", "I,m")) { + removeWordMethod.invoke(instance, word, isMainDictWordMethod.invoke(instance, word) as Boolean) + } + + assertFalse(isBlacklistedMethod.invoke(instance, "I'm") as Boolean) + assertFalse(isBlacklistedMethod.invoke(instance, "i'm") as Boolean) + assertTrue(isBlacklistedMethod.invoke(instance, "I,m") as Boolean) + } }