Deals with multi part filters

Anki deck search features allows to enter multiple part of the
filter. For example "math catego" allows to find the deck "category"
as a subdeck of "math", and exclude "category" in any deck that don't
also contains the word "math".

The same search on ankidroid would only return a deck whose name
contains "math catego" literally.

Also, a search for "h::cat" won't show the deck math::category as
ankidroid search for the string in the name of the deck not
considering the parents.

This commit tries to be as close as possible to anki
behaviour. However, anki deck selection uses a submenu that is very
different from ankidroid filtering process. So this commit tries to
keep the logic of ankidroid filtering process by ensuring that if we
search for "math::alge" we still shows "math::algebra" without showing
"math::algebra::group" in the deck picker.

A last complexity was that, when the user tap "math:", we don't want
to remove the deck "math" from the search result (as it'll reappear as
soon as the user has tapped "math::a", since "math" is a parent of
"math::algebra" and that we show parents of shown decks). So the
search feature considers in this case that "math:" can be either a
part of a name of a deck, or that "math" can be the suffix of a deck's
parent name.

A bunch of unit tests was added to help understand the behavior of the
search feature in mulitple cases.

Author: Arthur-Milchior

AnkiDroid/src/main/java/com/ichi2/anki/deckpicker/DeckFilters.kt

@@ -0,0 +1,173 @@
+/*
+ *  Copyright (c) 2026 Arthur Milchior <arthur@milchior.fr>
+ *
+ *  This program is free software; you can redistribute it and/or modify it under
+ *  the terms of the GNU General Public License as published by the Free Software
+ *  Foundation; either version 3 of the License, or (at your option) any later
+ *  version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ *  PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.ichi2.anki.deckpicker
+
+import android.annotation.SuppressLint
+import androidx.annotation.VisibleForTesting
+import java.util.Locale
+import kotlin.collections.filter
+import kotlin.sequences.filter
+import kotlin.text.filter
+
+/**
+ * Represents a deck search typed by the user, used to filter a list of decks.
+ */
+class DeckFilters
+    @VisibleForTesting
+    constructor(
+        private val filters: List<DeckFilter>,
+    ) {
+        /**
+         * Whether the user is searching something
+         */
+        fun searching() = filters.isNotEmpty()
+
+        /**
+         * Whether all filter of [filters] appear in [name]
+         */
+        @VisibleForTesting
+        fun deckNamesMatchFilters(name: String) = filters.all { filter -> filter.deckNameMatchesFilter(name) }
+
+        /**
+         * Whether at least one of the filter matches the last name.
+         * @See [deckLastNameMatchesFilter] to understand the exact meaning
+         */
+        @VisibleForTesting
+        fun deckLastNameMatchesAFilter(name: String) = filters.any { filter -> filter.deckLastNameMatchesFilter(name) }
+
+        /**
+         * Whether the deck with this full name must be kept for the current filter.
+         */
+        @VisibleForTesting
+        fun accept(name: String) =
+            !searching() ||
+                (
+                    deckLastNameMatchesAFilter(name) &&
+                        deckNamesMatchFilters(name)
+                )
+
+        /**
+         * Represents a single filter
+         * @param filter: a trimmed lower case string
+         */
+        class DeckFilter(
+            private val filter: String,
+        ) {
+            /**
+             * Whether there is a single : at the end. This case must be treated specially in order not to remove result from the deck list
+             * while the user starts tapping "::subdeckName"
+             */
+            val endsWithSingleColumn = filter.endsWith(":") && !filter.endsWith("::")
+
+            /**
+             * The filter without its last ":" if the deck name ends with exactly one ":"
+             */
+            val trimmedFilter = if (endsWithSingleColumn) filter.trimEnd(':') else filter
+
+            /**
+             * Whether [filter] appears in [name].
+             */
+            @SuppressLint("LocaleRootUsage")
+            fun deckNameMatchesFilter(name: String) =
+                // If the filter is "foo:", the user may wants "foo: we can match against "foo" at the end of the deck name or with "foo:" anywhere in the deck name
+                name.lowercase(Locale.getDefault()).contains(filter) ||
+                    name.lowercase(Locale.ROOT).contains(filter) ||
+                    name.lowercase(Locale.getDefault()).endsWith(trimmedFilter) ||
+                    name.lowercase(Locale.ROOT).endsWith(trimmedFilter)
+
+            /**
+             * Whether [filter] matches against the last part of [name] specifically.
+             * That is, if [filter] contains :: then the last suffix of the form "::foo", the name of the deck starts with "foo".
+             * Otherwise, the name contains "foo".
+             */
+            @VisibleForTesting
+            fun deckLastNameMatchesFilter(name: String): Boolean {
+                val indexOfSeparatorInFilter = filter.lastIndexOf("::")
+                if (indexOfSeparatorInFilter == -1) {
+                    // "::" does not appear in the filter. Then the filter can be anywhere in
+                    // the last part of the name
+                    return deckNameMatchesFilter(name.split("::").last())
+                }
+                // "::" appears in the filter. Then it must be the same as the last "::" in the name.
+                val indexOfSeparatorInName = name.lastIndexOf("::")
+                if (indexOfSeparatorInName == -1) {
+                    // This name does not correspond to a subdeck
+                    return false
+                }
+
+                // We use trimmed filter. This way:
+                // * if the filter does not ends with a :, this is similar to the filter
+                // * if the filter ends with a single :, we're actually considering the parent name
+                // the deck list will contains the parent.
+                // * If the filter ends with ::, the last deck of the filter is empty, so this last deck is not considered, instead we just check against second to last deck name
+                return containsAtPosition(
+                    trimmedFilter,
+                    indexOfSeparatorInFilter,
+                    name,
+                    indexOfSeparatorInName,
+                )
+            }
+
+            companion object {
+                /**
+                 * Whether [containing] contains [contained] where the positions matches.
+                 * Position must be less than the length of the string.
+                 */
+                @VisibleForTesting
+                fun containsAtPosition(
+                    contained: String,
+                    positionContained: Int,
+                    containing: String,
+                    positionContaining: Int,
+                ): Boolean {
+                    val startOfContainingInContained = positionContaining - positionContained
+                    val endOfContainingInContained = startOfContainingInContained + contained.length
+                    val substringInContaining: String
+                    try {
+                        substringInContaining =
+                            containing.substring(startOfContainingInContained, endOfContainingInContained)
+                    } catch (e: IndexOutOfBoundsException) {
+                        return false
+                    }
+                    return substringInContaining.lowercase(Locale.getDefault()) ==
+                        contained.lowercase(
+                            Locale.getDefault(),
+                        ) ||
+                        substringInContaining.equals(
+                            contained,
+                            ignoreCase = true,
+                        )
+                }
+            }
+        }
+
+        companion object {
+            /**
+             * Returns a DeckFilters for the user input [filters]
+             */
+            fun create(filters: String) =
+                DeckFilters(
+                    filters
+                        .lowercase()
+                        .split("\\s+".toRegex())
+                        .map { it.trim() }
+                        .filter {
+                            it.isNotEmpty()
+                        }.map { DeckFilter(it) },
+                )
+        }
+    }

AnkiDroid/src/main/java/com/ichi2/anki/deckpicker/DeckPickerViewModel.kt

@@ -89,7 +89,7 @@ class DeckPickerViewModel :
         }
 
     /** User filter of the deck list. Shown as a search in the UI */
-    private val flowOfCurrentDeckFilter = MutableStateFlow("")
+    private val flowOfCurrentDeckFilter = MutableStateFlow(DeckFilters.create(""))
 
     /**
      * Keep track of which deck was last given focus in the deck list. If we find that this value
@@ -390,7 +390,7 @@ class DeckPickerViewModel :
 
     fun updateDeckFilter(filterText: String) {
         Timber.d("filter: %s", filterText)
-        flowOfCurrentDeckFilter.value = filterText
+        flowOfCurrentDeckFilter.value = DeckFilters.create(filterText)
     }
 
     fun toggleDeckExpand(deckId: DeckId) =

AnkiDroid/src/main/java/com/ichi2/anki/deckpicker/DisplayDeckNode.kt

@@ -17,7 +17,6 @@
 
 package com.ichi2.anki.deckpicker
 
-import android.annotation.SuppressLint
 import androidx.annotation.VisibleForTesting
 import com.ichi2.anki.libanki.DeckId
 import com.ichi2.anki.libanki.sched.DeckNode
@@ -79,33 +78,27 @@ data class DisplayDeckNode private constructor(
 /** Convert the tree into a flat list of [DisplayDeckNode]s, where matching decks and the children/parents
  * are included. Decks inside collapsed decks are not considered. */
 fun DeckNode.filterAndFlattenDisplay(
-    filter: CharSequence?,
+    filter: DeckFilters,
     selectedDeckId: DeckId,
 ): List<DisplayDeckNode> {
-    val filterPattern =
-        if (filter.isNullOrBlank()) {
-            null
-        } else {
-            filter.toString().lowercase(Locale.getDefault()).trim()
-        }
     val list = mutableListOf<DisplayDeckNode>()
-    filterAndFlattenDisplayInner(filterPattern, list, parentMatched = false, selectedDeckId)
+    filterAndFlattenDisplayInner(filter, list, parentMatched = false, selectedDeckId)
     return list
 }
 
 private fun DeckNode.filterAndFlattenDisplayInner(
-    filter: CharSequence?,
+    filter: DeckFilters,
     list: MutableList<DisplayDeckNode>,
     parentMatched: Boolean,
     selectedDeckId: DeckId,
 ) {
-    if (!isSyntheticDeck && (nameMatchesFilter((filter)) || parentMatched)) {
+    if (!isSyntheticDeck && (filter.accept(fullDeckName) || parentMatched)) {
         this.addVisibleToList(list, matchesSearchOrChild = true, selectedDeckId)
         return
     }
 
     // When searching, ignore collapsed state and always search children
-    val searching = filter != null
+    val searching = filter.searching()
     if (collapsed && !searching) {
         return
     }
@@ -151,12 +144,3 @@ fun DeckNode.addVisibleToList(list: MutableList<DeckNode>) {
         }
     }
 }
-
-@SuppressLint("LocaleRootUsage")
-private fun DeckNode.nameMatchesFilter(filter: CharSequence?): Boolean {
-    return if (filter == null) {
-        true
-    } else {
-        return node.name.lowercase(Locale.getDefault()).contains(filter) || node.name.lowercase(Locale.ROOT).contains(filter)
-    }
-}

AnkiDroid/src/main/java/com/ichi2/anki/dialogs/DeckSelectionDialog.kt

@@ -376,15 +376,28 @@ open class DeckSelectionDialog : AnalyticsDialogFragment() {
         override fun getFilter(): Filter = DecksFilter()
 
         private inner class DecksFilter : TypedFilter<DeckNode>(allDecksList) {
+            /**
+             * Returns all the deck nodes of [items] that contains every pattern of the constraints.
+             * In the constraints, patterns are separated by any whitespace character.
+             */
             override fun filterResults(
                 constraint: CharSequence,
                 items: List<DeckNode>,
-            ): List<DeckNode> {
-                val filterPattern = constraint.toString().lowercase(Locale.getDefault()).trim()
-                return items.filter {
-                    it.fullDeckName.lowercase(Locale.getDefault()).contains(filterPattern)
+            ) = constraint
+                .toString()
+                .lowercase(Locale.getDefault())
+                .split("\\s+".toRegex())
+                .map { it.trim() }
+                .filter { it.isNotEmpty() }
+                .fold(items) { items, filterPattern ->
+                    // Returns the deck nodes that contains all the patterns
+                    items.filter { deck ->
+                        deck
+                            .fullDeckName
+                            .lowercase(Locale.getDefault())
+                            .contains(filterPattern)
+                    }
                 }
-            }
 
             override fun publishResults(
                 constraint: CharSequence?,

AnkiDroid/src/main/java/com/ichi2/anki/utils/ext/Deck.kt

@@ -16,9 +16,15 @@
 
 package com.ichi2.anki.utils.ext
 
+import android.R.attr.name
+import android.annotation.SuppressLint
+import androidx.annotation.VisibleForTesting
 import com.ichi2.anki.libanki.Deck
 import com.ichi2.anki.libanki.DeckId
 import com.ichi2.anki.libanki.Decks
+import com.ichi2.anki.libanki.sched.DeckNode
+import java.util.Locale
+import kotlin.collections.any
 
 fun Decks.update(
     did: DeckId,