fix: TaskGroupingTree no longer loses any tasks with no group names.

This never affected released code as all the released groupers
ensure that every task has at least one group name.

However, with the development of custom groupers, I discovered
it was possible to have query results displayed that said they
had 100 tasks, but only display some of them, as the ones
with no group names were just not displayed.

Author: claremacrae

src/Query/TaskGroupingTree.ts

@@ -67,6 +67,14 @@ export class TaskGroupingTree {
                     // Get properties of a task for the grouper
                     // The returned string is rendered, so special Markdown characters will be escaped
                     const groupNames = grouper.grouper(task);
+
+                    if (groupNames.length === 0) {
+                        // Create a fake empty group-name so that we can add these tasks
+                        // to the tree. This group will be displayed with no heading.
+                        // Without this, they would be lost and not displayed at all the query results.
+                        groupNames.push('');
+                    }
+
                     for (const groupName of groupNames) {
                         let child = currentTreeNode.children.get(groupName);
                         if (child === undefined) {

src/Query/TaskGroups.ts

@@ -153,10 +153,20 @@ export class TaskGroups {
             group.applyTaskLimit(limit);
         });
 
-        this.calculateTotalTaskCount();
+        this.recalculateTotalTaskCount();
     }
 
-    private calculateTotalTaskCount() {
+    /**
+     * Update the stored task count to represent the number of unique tasks
+     * across all the groups.
+     *
+     * In normal operation this is only useful after a limit to group size
+     * has been applied.
+     *
+     * However, it is also useful for test code to be able to ensure consistency
+     * of task count after the object has been initially constructed.
+     */
+    public recalculateTotalTaskCount() {
         let concatenatedTasks: Task[] = [];
 
         this._groups.forEach((group) => {

tests/TaskGroups.test.ts

@@ -3,7 +3,7 @@
  */
 import moment from 'moment';
 import { FilenameField } from '../src/Query/Filter/FilenameField';
-import type { Grouper } from '../src/Query/Grouper';
+import { Grouper, type GrouperFunction } from '../src/Query/Grouper';
 import type { Task } from '../src/Task';
 import { PathField } from '../src/Query/Filter/PathField';
 import { TagsField } from '../src/Query/Filter/TagsField';
@@ -242,6 +242,46 @@ describe('Grouping tasks', () => {
         `);
     });
 
+    it('should retain tasks with no group name', () => {
+        const a = fromLine({
+            line: '- [ ] Task with a tag #group1',
+        });
+        const b = fromLine({
+            line: '- [ ] Task without a tag',
+        });
+        const inputs = [a, b];
+
+        const groupByTags: GrouperFunction = (task: Task) => task.tags;
+        const grouper = new Grouper('custom tag grouper', groupByTags, false);
+        const groups = new TaskGroups([grouper], inputs);
+
+        expect(groups.totalTasksCount()).toEqual(2);
+
+        // Force a recalculation of the task count, to ensure no
+        // tasks were lost in the grouping:
+        groups.recalculateTotalTaskCount();
+        expect(groups.totalTasksCount()).toEqual(2);
+
+        expect(groups.toString()).toMatchInlineSnapshot(`
+            "Groupers (if any):
+            - custom tag grouper
+
+            Group names: []
+            - [ ] Task without a tag
+
+            ---
+
+            Group names: [#group1]
+            #### [custom tag grouper] #group1
+            - [ ] Task with a tag #group1
+
+            ---
+
+            2 tasks
+            "
+        `);
+    });
+
     it('should create nested headings if multiple groups used even if one is reversed', () => {
         // Arrange
         const t1 = fromLine({