Refactor(search): Implement advanced fuzzy search algorithm

CreativeCodeCat · CreativeCodeCat · commit 0c1133751b9f · 2026-01-14T17:49:29.000Z
This commit replaces the basic fuzzy search logic with a more advanced scoring algorithm in `FuzzyFinder`.

The new `calculateFuzzyScore` implementation provides more relevant search results by assigning weighted scores for:
-   Character matches
-   Consecutive character matches
-   Matches at the beginning of a word
-   Matches at the start of the string

Normalization logic has been refined to distinguish between search queries and target strings (`normalizeSearch`, `normalizeTarget`), preserving spaces in the target to accurately identify word boundaries for scoring. The old, simpler scoring logic has been removed.

The `AppDrawerAdapter` is updated to utilize this new scoring mechanism, improving the filtering logic for app searches. Additionally, the JUnit dependency has been added for future testing.
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -232,4 +232,6 @@ dependencies {
 
     debugImplementation(libs.fragment.testing)
     androidTestImplementation(libs.navigation.testing)
+
+    testImplementation(libs.junit)
 }
diff --git a/app/src/main/java/com/github/codeworkscreativehub/fuzzywuzzy/FuzzyFinder.kt b/app/src/main/java/com/github/codeworkscreativehub/fuzzywuzzy/FuzzyFinder.kt
@@ -8,81 +8,132 @@ import java.util.Locale
 
 object FuzzyFinder {
 
+    /**
+     * Scores an AppListItem based on its activity label.
+     */
     fun scoreApp(app: AppListItem, searchChars: String, topScore: Int): Int {
         val appLabel = app.activityLabel
-        val normalizedAppLabel = normalizeString(appLabel)
-        val normalizedSearchChars = normalizeString(searchChars)
+        val normalizedAppLabel = normalizeTarget(appLabel)
+        val normalizedSearchChars = normalizeSearch(searchChars)
 
         val fuzzyScore = calculateFuzzyScore(normalizedAppLabel, normalizedSearchChars)
         return (fuzzyScore * topScore).toInt()
     }
 
+    /**
+     * Scores a ContactListItem based on its display name.
+     */
     fun scoreContact(contact: ContactListItem, searchChars: String, topScore: Int): Int {
         val contactLabel = contact.displayName
-        val normalizedContactLabel = normalizeString(contactLabel)
-        val normalizedSearchChars = normalizeString(searchChars)
+        val normalizedContactLabel = normalizeTarget(contactLabel)
+        val normalizedSearchChars = normalizeSearch(searchChars)
 
         val fuzzyScore = calculateFuzzyScore(normalizedContactLabel, normalizedSearchChars)
         return (fuzzyScore * topScore).toInt()
     }
 
-    fun scoreString(appLabel: String, searchChars: String, topScore: Int): Int {
-        val normalizedAppLabel = normalizeString(appLabel)
-        val normalizedSearchChars = normalizeString(searchChars)
+    /**
+     * Scores a raw string against a search query.
+     */
+    fun scoreString(target: String, searchChars: String, topScore: Int): Int {
+        val normalizedTarget = normalizeTarget(target)
+        val normalizedSearchChars = normalizeSearch(searchChars)
 
-        val fuzzyScore = calculateFuzzyScore(normalizedAppLabel, normalizedSearchChars)
+        val fuzzyScore = calculateFuzzyScore(normalizedTarget, normalizedSearchChars)
         return (fuzzyScore * topScore).toInt()
     }
 
-    // Simplified normalization for app label and search string
-    private fun normalizeString(input: String): String {
-        return input
-            .uppercase(Locale.getDefault())
-            .let { normalizeDiacritics(it) }
-            .replace(Regex("[-_+,. ]"), emptyString())
-    }
+    /**
+     * Advanced Fuzzy Matching Score.
+     * Returns a float between 0.0 and 1.0.
+     * 1.0 represents a perfect prefix match.
+     */
+    internal fun calculateFuzzyScore(haystack: String, needle: String): Float {
+        if (needle.isEmpty() || haystack.isEmpty()) return 0f
+
+        val n = needle.length
+        val m = haystack.length
+        if (n > m) return 0f
+
+        val scoreMatch = 100
+        val scoreConsecutive = 90
+        val scoreWordStart = 80
+        val scoreStartIdxBonus = 15
+
+        var currentScore = 0
+        var needleIdx = 0
+        var prevHaystackIdx = -1
+
+        // 1. Actual Score Loop
+        for (i in 0 until m) {
+            if (needleIdx >= n) break
+            if (haystack[i] == needle[needleIdx]) {
+                var charScore = scoreMatch
+                if (prevHaystackIdx != -1 && i == prevHaystackIdx + 1) charScore += scoreConsecutive
+
+                val isWordStart = if (i == 0) true else {
+                    val prevChar = haystack[i - 1]
+                    prevChar == ' ' || prevChar == '.' || prevChar == '_' || prevChar == '-' || prevChar == ','
+                }
+                if (isWordStart) charScore += scoreWordStart
+                if (i < 3) charScore += scoreStartIdxBonus
 
-    // Remove diacritics from a string
-    private fun normalizeDiacritics(input: String): String {
-        return Normalizer.normalize(input, Normalizer.Form.NFD)
-            .replace(Regex("\\p{InCombiningDiacriticalMarks}+"), emptyString())
-    }
+                currentScore += charScore
+                prevHaystackIdx = i
+                needleIdx++
+            }
+        }
 
-    // Function to check if normalized strings match
-    fun isMatch(appLabel: String, searchChars: String): Boolean {
-        val normalizedAppLabel = normalizeString(appLabel)
-        val normalizedSearchChars = normalizeString(searchChars)
+        if (needleIdx < n) return 0f
 
-        return normalizedAppLabel.contains(normalizedSearchChars, ignoreCase = true)
-    }
+        // 2. Corrected Perfect Max Score
+        // We only calculate the potential score for characters that ARE NOT spaces.
+        var perfectMaxScore = 0
+        for (i in 0 until m) {
+            if (haystack[i] == ' ') continue // <--- SKIP spaces in the denominator!
 
-    // Fuzzy matching logic (kept as it is)
-    private fun calculateFuzzyScore(s1: String, s2: String): Float {
-        val m = s1.length
-        val n = s2.length
-        var matchCount = 0
-        var s1Index = 0
-
-        // Iterate over each character in s2 and check if it exists in s1
-        for (c2 in s2) {
-            var found = false
-
-            // Start searching for c2 from the current s1Index
-            for (j in s1Index until m) {
-                if (s1[j] == c2) {
-                    found = true
-                    s1Index = j + 1  // Move to the next position in s1
-                    break
-                }
+            var potential = scoreMatch
+            val isWordStart = if (i == 0) true else {
+                val prevChar = haystack[i - 1]
+                prevChar == ' ' || prevChar == '.' || prevChar == '_' || prevChar == '-' || prevChar == ','
             }
 
-            // If the current character in s2 is not found in s1, return a score of 0
-            if (!found) return 0f
+            potential += if (isWordStart) scoreWordStart else scoreConsecutive
+            if (i < 3) potential += scoreStartIdxBonus
 
-            matchCount++
+            perfectMaxScore += potential
         }
 
-        // Return score based on the ratio of matched characters to the longer string length
-        return matchCount.toFloat() / maxOf(m, n)
+        return if (perfectMaxScore == 0) 0f else currentScore.toFloat() / perfectMaxScore
+    }
+
+    /**
+     * Simple boolean match for legacy support or low-power filtering.
+     */
+    fun isMatch(target: String, searchChars: String): Boolean {
+        val normalizedTarget = normalizeString(target)
+        val normalizedSearch = normalizeString(searchChars)
+        return normalizedTarget.contains(normalizedSearch)
+    }
+
+    // --- Normalization Helpers ---
+    private fun normalizeString(input: String): String {
+        return normalizeDiacritics(input.uppercase(Locale.getDefault()))
+            .replace(Regex("[-_+,. ]"), emptyString())
+    }
+
+    private fun normalizeSearch(input: String): String {
+        return normalizeDiacritics(input.uppercase(Locale.getDefault()))
+            .replace(Regex("[-_+,. ]"), emptyString())
+    }
+
+    private fun normalizeTarget(input: String): String {
+        return normalizeDiacritics(input.uppercase(Locale.getDefault()))
+            .replace(Regex("[-_+,.]"), " ") // Keep spaces to detect word boundaries
+    }
+
+    private fun normalizeDiacritics(input: String): String {
+        return Normalizer.normalize(input, Normalizer.Form.NFD)
+            .replace(Regex("\\p{InCombiningDiacriticalMarks}+"), emptyString())
     }
 }
diff --git a/app/src/main/java/com/github/codeworkscreativehub/mlauncher/ui/adapter/AppDrawerAdapter.kt b/app/src/main/java/com/github/codeworkscreativehub/mlauncher/ui/adapter/AppDrawerAdapter.kt
@@ -216,39 +216,45 @@ class AppDrawerAdapter(
                 val normalizeField: (AppListItem) -> String = { app -> if (isTagSearch) normalize(app.tag) else normalize(app.activityLabel) }
 
                 // Scoring logic
+                // 1. Calculate the scores for all apps in the list
                 val scoredApps: Map<AppListItem, Int> = if (prefs.enableFilterStrength) {
                     appsList.associateWith { app ->
                         if (isTagSearch) {
-                            FuzzyFinder.scoreString(normalize(app.tag), query, Constants.MAX_FILTER_STRENGTH)
+                            // Normalizing the app tag and scoring it against the query
+                            FuzzyFinder.scoreString(app.tag, query, Constants.MAX_FILTER_STRENGTH)
                         } else {
+                            // Using the specialized scoreApp helper for AppListItems
                             FuzzyFinder.scoreApp(app, query, Constants.MAX_FILTER_STRENGTH)
                         }
                     }
                 } else {
+                    // If filter strength is disabled, we don't calculate fuzzy scores
                     emptyMap()
                 }
 
+                // 2. Filter the list based on the fuzzy score and the user's preferences
                 filteredApps = if (searchChars.isEmpty()) {
                     appsList.toMutableList()
                 } else {
                     val filtered = if (prefs.enableFilterStrength) {
-                        // Filter using scores
+                        // Logic: Use the pre-calculated scores.
+                        // If the score is above the threshold, it's a valid match.
                         scoredApps.filter { (app, score) ->
-                            (prefs.searchFromStart && normalizeField(app).startsWith(query) ||
-                                    !prefs.searchFromStart && normalizeField(app).contains(query))
-                                    && score > prefs.filterStrength
+                            AppLogger.d("appScore", "app: ${app.activityLabel} | score: $score")
+                            score > prefs.filterStrength
                         }.map { it.key }
                     } else {
-                        // Filter without scores
+                        // Logic: Simple Boolean matching without scoring.
                         appsList.filter { app ->
+                            val target = normalizeField(app)
                             if (prefs.searchFromStart) {
-                                normalizeField(app).startsWith(query)
+                                target.startsWith(query)
                             } else {
-                                FuzzyFinder.isMatch(normalizeField(app), query)
+                                // Uses your new isMatch helper for a simple true/false fuzzy check
+                                FuzzyFinder.isMatch(target, query)
                             }
                         }
                     }
-
                     filtered.toMutableList()
                 }
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -4,6 +4,7 @@
 agp = "8.13.2"
 kotlin = "2.3.0"
 viewpager2 = "1.1.0"
+junit = "4.13.2"
 
 # AndroidX Core and AppCompat
 core-ktx = "1.17.0"
@@ -117,6 +118,7 @@ test-rules = { group = "androidx.test", name = "rules", version.ref = "test-rule
 fragment-testing = { group = "androidx.fragment", name = "fragment-testing", version.ref = "fragment-testing" }
 ui-test-junit4 = { group = "androidx.compose.ui", name = "ui-test-junit4", version.ref = "ui-test-junit4" }
 ui-test-manifest = { group = "androidx.compose.ui", name = "ui-test-manifest", version.ref = "ui-test-manifest" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

Original file line number	Diff line number	Diff line change
`@@ -232,4 +232,6 @@ dependencies {`
`232`	`232`
`233`	`233`	`debugImplementation(libs.fragment.testing)`
`234`	`234`	`androidTestImplementation(libs.navigation.testing)`
	`235`	`+`
	`236`	`+ testImplementation(libs.junit)`
`235`	`237`	`}`