feat: change names of groups from Priority Field and change the sort of order groups same as task sorting order

docs/Queries/Grouping.md

@@ -77,10 +77,10 @@ For more information, including adding your own customised statuses, see [[Statu
 
 1. `priority`
     - The priority of the task, namely one of:
-        - `Priority 1: High`
-        - `Priority 2: Medium`
-        - `Priority 3: None`
-        - `Priority 4: Low`
+        - `High`
+        - `Medium`
+        - `None`
+        - `Low`
 1. `urgency` ([[Urgency|urgency]])
     - Currently, the groups run from the lowest urgency to highest.
     - You can reverse this with `group by urgency reverse`.

src/Query/Filter/Field.ts

@@ -360,7 +360,7 @@ export abstract class Field {
      * @param reverse - false for normal group order, true for reverse group order.
      */
     public createGrouper(reverse: boolean): Grouper {
-        return new Grouper(this.fieldNameSingular(), this.grouper(), reverse);
+        return new Grouper(this.fieldNameSingular(), this.grouper(), reverse, this.comparator());
     }
 
     /**

src/Query/Filter/MultiTextField.ts

@@ -64,7 +64,7 @@ export abstract class MultiTextField extends TextField {
      * This overloads {@link Field.createGrouper} to put a plural field name in the {@link Grouper.property}.
      */
     public createGrouper(reverse: boolean): Grouper {
-        return new Grouper(this.fieldNamePlural(), this.grouper(), reverse);
+        return new Grouper(this.fieldNamePlural(), this.grouper(), reverse, this.comparator());
     }
 
     protected grouperRegExp(): RegExp {

src/Query/Filter/PriorityField.ts

@@ -87,22 +87,18 @@ export class PriorityField extends Field {
 
     public grouper(): GrouperFunction {
         return (task: Task) => {
-            let priorityName = 'ERROR';
             switch (task.priority) {
                 case Priority.High:
-                    priorityName = 'High';
-                    break;
+                    return ['High'];
                 case Priority.Medium:
-                    priorityName = 'Medium';
-                    break;
+                    return ['Medium'];
                 case Priority.None:
-                    priorityName = 'None';
-                    break;
+                    return ['None'];
                 case Priority.Low:
-                    priorityName = 'Low';
-                    break;
+                    return ['Low'];
+                default:
+                    return ['ERROR'];
             }
-            return [`Priority ${task.priority}: ${priorityName}`];
         };
     }
 }

src/Query/Grouper.ts

@@ -1,4 +1,5 @@
 import type { Task } from '../Task';
+import type { Comparator } from './Sorter';
 
 /**
  * A group-naming function, that takes a Task object and returns zero or more
@@ -36,9 +37,12 @@ export class Grouper {
 
     public readonly reverse: boolean;
 
-    constructor(property: string, grouper: GrouperFunction, reverse: boolean) {
+    public readonly groupComparator: Comparator;
+
+    constructor(property: string, grouper: GrouperFunction, reverse: boolean, groupComparator: Comparator) {
         this.property = property;
         this.grouper = grouper;
         this.reverse = reverse;
+        this.groupComparator = groupComparator;
     }
 }

src/Query/TaskGroups.ts

@@ -105,18 +105,10 @@ export class TaskGroups {
 
     private sortTaskGroups() {
         const compareFn = (group1: TaskGroup, group2: TaskGroup) => {
-            // Compare two TaskGroup objects, sorting them by the group names at each grouping level.
-            const groupNames1 = group1.groups;
-            const groupNames2 = group2.groups;
-            // The containers are guaranteed to be identical sizes,
-            // they have one value for each 'group by' line in the query.
-            for (let i = 0; i < groupNames1.length; i++) {
-                // For now, we only have one sort option: sort by the names of the groups.
-                // In future, we will add control over the sorting of group headings,
-                // which will likely involve adjusting this code to sort by applying a Comparator
-                // to the first Task in each group.
+            // Compare two TaskGroup objects, sorting them by first task in each group.
+            for (let i = 0; i < this._groupers.length; i++) {
                 const grouper = this._groupers[i];
-                const result = groupNames1[i].localeCompare(groupNames2[i], undefined, { numeric: true });
+                const result = grouper.groupComparator(group1.tasks[0], group2.tasks[0]);
                 if (result !== 0) {
                     return grouper.reverse ? -result : result;
                 }

tests/Query/Filter/PriorityField.test.ts

@@ -3,7 +3,7 @@ import { TaskBuilder } from '../../TestingTools/TaskBuilder';
 import { testFilter } from '../../TestingTools/FilterTestHelpers';
 import { PriorityField } from '../../../src/Query/Filter/PriorityField';
 import { fromLine } from '../../TestHelpers';
-
+import { TaskGroups } from '../../../src/Query/TaskGroups';
 import {
     expectTaskComparesAfter,
     expectTaskComparesBefore,
@@ -163,15 +163,61 @@ describe('grouping by priority', () => {
     });
 
     it.each([
-        ['- [ ] a ⏫', ['Priority 1: High']],
-        ['- [ ] a 🔼', ['Priority 2: Medium']],
-        ['- [ ] a', ['Priority 3: None']],
-        ['- [ ] a 🔽', ['Priority 4: Low']],
+        ['- [ ] a ⏫', ['High']],
+        ['- [ ] a 🔼', ['Medium']],
+        ['- [ ] a', ['None']],
+        ['- [ ] a 🔽', ['Low']],
     ])('task "%s" should have groups: %s', (taskLine: string, groups: string[]) => {
         // Arrange
         const grouper = new PriorityField().createNormalGrouper().grouper;
 
         // Assert
         expect(grouper(fromLine({ line: taskLine }))).toEqual(groups);
     });
+
+    it('should sort groups according to priority meaning', () => {
+        // Arrange
+        const tasks = [
+            fromLine({ line: '- [ ] a 🔽' }),
+            fromLine({ line: '- [ ] a ⏫' }),
+            fromLine({ line: '- [ ] a' }),
+            fromLine({ line: '- [ ] a 🔼' }),
+        ];
+
+        const grouper = [new PriorityField().createNormalGrouper()];
+        const groups = new TaskGroups(grouper, tasks);
+
+        // Assert
+        expect(groups.toString()).toMatchInlineSnapshot(`
+            "Groupers (if any):
+            - priority
+
+            Group names: [High]
+            #### [priority] High
+            - [ ] a ⏫
+
+            ---
+
+            Group names: [Medium]
+            #### [priority] Medium
+            - [ ] a 🔼
+
+            ---
+
+            Group names: [None]
+            #### [priority] None
+            - [ ] a
+
+            ---
+
+            Group names: [Low]
+            #### [priority] Low
+            - [ ] a 🔽
+
+            ---
+
+            4 tasks
+            "
+        `);
+    });
 });