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) + } }