Fix group filter to use OR semantics for space separated terms

CHANGELOG.md

@@ -34,6 +34,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 
 ### Fixed
 
+- We fixed the group filter to use OR semantics for space-separated terms, so typing `machine learning` now shows all groups containing either word instead of requiring both. [#12721](https://github.com/JabRef/jabref/issues/12721)
 - We fixed RIS export writing the full page range into both start page and end page fields instead of splitting them correctly. [#15106](https://github.com/JabRef/jabref/issues/15106)
 - We fixed an issue where shortcut keys did not work for linked files in the entry editor. [#12564](https://github.com/JabRef/jabref/issues/12564)
 - We fixed the issue where incomplete search produced noisy error logs when entering input in the search bar. [#14632](https://github.com/JabRef/jabref/issues/14632)

jabgui/src/main/java/org/jabref/gui/groups/GroupNodeViewModel.java

@@ -28,6 +28,7 @@
 import org.jabref.gui.util.UiTaskExecutor;
 import org.jabref.logic.groups.GroupsFactory;
 import org.jabref.logic.layout.format.LatexToUnicodeFormatter;
+import org.jabref.logic.search.query.GroupNameFilterVisitor;
 import org.jabref.logic.util.BackgroundTask;
 import org.jabref.logic.util.TaskExecutor;
 import org.jabref.logic.util.strings.StringUtil;
@@ -55,6 +56,8 @@
 import org.jabref.model.search.event.IndexClosedEvent;
 import org.jabref.model.search.event.IndexRemovedEvent;
 import org.jabref.model.search.event.IndexStartedEvent;
+import org.jabref.model.search.query.SearchQuery;
+import org.jabref.search.SearchParser;
 
 import com.google.common.eventbus.Subscribe;
 import com.tobiasdiez.easybind.EasyBind;
@@ -332,7 +335,17 @@ void toggleExpansion() {
     }
 
     boolean isMatchedBy(String searchString) {
-        return StringUtil.isBlank(searchString) || StringUtil.containsIgnoreCase(getDisplayName(), searchString);
+        if (StringUtil.isBlank(searchString)) {
+            return true;
+        }
+        try {
+            SearchParser.StartContext ctx = SearchQuery.getStartContext(searchString);
+            GroupNameFilterVisitor visitor = new GroupNameFilterVisitor(getDisplayName());
+            return visitor.visit(ctx);
+        } catch (org.antlr.v4.runtime.misc.ParseCancellationException e) {
+            // Malformed query: fall back to plain contains
+            return StringUtil.containsIgnoreCase(getDisplayName(), searchString);
+        }
     }
 
     public Color getColor() {
@@ -351,7 +364,6 @@ public Optional<GroupNodeViewModel> getChildByPath(String pathToSource) {
     ///
     /// - another group (will be added as subgroup on drop)
     /// - entries if the group implements {@link GroupEntryChanger} (will be assigned to group on drop)
-    ///
     public boolean acceptableDrop(Dragboard dragboard) {
         // TODO: we should also check isNodeDescendant
         boolean canDropOtherGroup = dragboard.hasContent(DragAndDropDataFormats.GROUP);

jabgui/src/test/java/org/jabref/gui/groups/GroupNodeViewModelFilterTest.java

@@ -0,0 +1,90 @@
+package org.jabref.gui.groups;
+
+import org.jabref.logic.search.query.GroupNameFilterVisitor;
+import org.jabref.model.search.query.SearchQuery;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GroupNodeViewModelFilterTest {
+
+    private boolean matches(String groupName, String query) {
+        if (query == null || query.isBlank()) {
+            return true;
+        }
+        try {
+            var ctx = SearchQuery.getStartContext(query);
+            return new GroupNameFilterVisitor(groupName).visit(ctx);
+        } catch (org.antlr.v4.runtime.misc.ParseCancellationException e) {
+            return groupName.toLowerCase().contains(query.toLowerCase());
+        }
+    }
+
+    @Test
+    void spaceImpliesOrFirstToken() {
+        assertTrue(matches("machine", "machine learning"));
+    }
+
+    @Test
+    void spaceImpliesOrSecondToken() {
+        assertTrue(matches("learning", "machine learning"));
+    }
+
+    @Test
+    void spaceImpliesOrBothTokens() {
+        assertTrue(matches("machine learning", "machine learning"));
+    }
+
+    @Test
+    void explicitAndRequiresBothWords() {
+        assertFalse(matches("machine", "machine AND neural"));
+        assertTrue(matches("machine neural", "machine AND neural"));
+    }
+
+    @Test
+    void explicitOrWorks() {
+        assertTrue(matches("machine", "machine OR neural"));
+        assertTrue(matches("neural", "machine OR neural"));
+        assertFalse(matches("unrelated", "machine OR neural"));
+    }
+
+    @Test
+    void notWorks() {
+        assertFalse(matches("machine", "NOT machine"));
+        assertTrue(matches("learning", "NOT machine"));
+    }
+
+    @Test
+    void blankQueryMatchesAll() {
+        assertTrue(matches("anything", ""));
+        assertTrue(matches("anything", "   "));
+    }
+
+    @Test
+    void caseInsensitiveMatch() {
+        assertTrue(matches("Machine Learning", "machine"));
+        assertTrue(matches("machine learning", "MACHINE"));
+    }
+
+    @Test
+    void malformedQueryFallsBackToContains() {
+        assertTrue(matches("test group", "test"));
+    }
+
+    @Test
+    void parenthesesWithNotWork() {
+        assertTrue(matches("Deep Learning", "(deep OR neural) NOT vision"));
+        assertTrue(matches("Neural Networks", "(deep OR neural) NOT vision"));
+        assertFalse(matches("Computer Vision", "(deep OR neural) NOT vision"));
+        assertFalse(matches("Machine Learning", "(deep OR neural) NOT vision"));
+    }
+
+    @Test
+    void complexExpressionWithNotLearning() {
+        assertTrue(matches("Computer Vision", "(machine OR computer) NOT learning"));
+        assertFalse(matches("Machine Learning", "(machine OR computer) NOT learning"));
+        assertFalse(matches("Neural Networks", "(machine OR computer) NOT learning"));
+    }
+}

jablib/src/main/java/org/jabref/logic/search/query/GroupNameFilterVisitor.java

@@ -0,0 +1,73 @@
+package org.jabref.logic.search.query;
+
+import org.jabref.search.SearchBaseVisitor;
+import org.jabref.search.SearchParser;
+
+/**
+ * Evaluates a Search.g4 parse tree against a group display name string.
+ * Key behavioral difference from {@link SearchQueryVisitor}:
+ * {@code visitImplicitAndExpression} uses OR semantics (anyMatch) instead of AND,
+ * so space-separated bare terms like "machine learning" match any group containing
+ * either word. Explicit AND/OR/NOT and parentheses work as expected.
+ */
+
+public class GroupNameFilterVisitor extends SearchBaseVisitor<Boolean> {
+
+    private final String groupName;
+
+    public GroupNameFilterVisitor(String groupName) {
+        this.groupName = groupName.toLowerCase();
+    }
+
+    @Override
+    public Boolean visitStart(SearchParser.StartContext ctx) {
+        if (ctx.andExpression() == null) {
+            return true;
+        }
+        return visit(ctx.andExpression());
+    }
+
+    @Override
+    public Boolean visitImplicitAndExpression(SearchParser.ImplicitAndExpressionContext ctx) {
+        if (ctx.expression().size() == 1) {
+            return visit(ctx.expression().getFirst());
+        }
+        boolean allSimpleTerm = ctx.expression().stream()
+                                   .allMatch(e -> e instanceof SearchParser.ComparisonExpressionContext);
+        if (allSimpleTerm) {
+            return ctx.expression().stream().anyMatch(this::visit);
+        } else {
+            return ctx.expression().stream().allMatch(this::visit);
+        }
+    }
+
+    @Override
+    public Boolean visitBinaryExpression(SearchParser.BinaryExpressionContext ctx) {
+        boolean left = visit(ctx.left);
+        boolean right = visit(ctx.right);
+        return ctx.bin_op.getType() == SearchParser.AND
+               ? left && right
+               : left || right;
+    }
+
+    @Override
+    public Boolean visitNegatedExpression(SearchParser.NegatedExpressionContext ctx) {
+        return !visit(ctx.expression());
+    }
+
+    @Override
+    public Boolean visitParenExpression(SearchParser.ParenExpressionContext ctx) {
+        return visit(ctx.andExpression());
+    }
+
+    @Override
+    public Boolean visitComparisonExpression(SearchParser.ComparisonExpressionContext ctx) {
+        return visit(ctx.comparison());
+    }
+
+    @Override
+    public Boolean visitComparison(SearchParser.ComparisonContext ctx) {
+        String term = SearchQueryConversion.unescapeSearchValue(ctx.searchValue()).toLowerCase();
+        return groupName.contains(term);
+    }
+}