feat: Allow additional tasks states and filtering by states #675

scripts/Test-TasksInLocalObsidian.ps1

@@ -1,11 +1,7 @@
 [CmdletBinding()]
-param (
-    [Parameter(HelpMessage = 'The path to the plugins folder uner the .obsidian directory.')]
-    [String]
-    $ObsidianPluginRoot = $env:OBSIDIAN_PLUGIN_ROOT,
-    [Parameter(HelpMessage = 'The folder name of the plugin to copy the files to.')]
-    [String]
-    $PluginFolderName = 'obsidian-tasks-plugin'
+[Parameter(HelpMessage = 'The folder name of the plugin to copy the files to.')]
+[String]
+$PluginFolderName = 'obsidian-tasks-plugin'
 )
 
 $repoRoot = (Resolve-Path -Path $(git rev-parse --show-toplevel)).Path
@@ -50,4 +46,8 @@ if ($?) {
     Write-Error 'Build failed'
 }
 
+Pop-Location
+    Write-Error 'Build failed'
+}
+
 Pop-Location

src/Commands/CreateOrEdit.ts

@@ -1,6 +1,8 @@
 import { App, Editor, MarkdownView, View } from 'obsidian';
+import { StatusRegistry } from 'StatusRegistry';
 import { TaskModal } from '../TaskModal';
-import { Priority, Status, Task } from '../Task';
+import { Status } from '../Status';
+import { Priority, Task } from '../Task';
 
 export const createOrEdit = (
     checking: boolean,
@@ -64,11 +66,10 @@ const taskFromLine = ({ line, path }: { line: string; path: string }): Task => {
         // Should never happen; everything in the regex is optional.
         console.error('Tasks: Cannot create task on line:', line);
         return new Task({
-            status: Status.Todo,
+            status: Status.TODO,
             description: '',
             path,
             indentation: '',
-            originalStatusCharacter: ' ',
             priority: Priority.None,
             startDate: null,
             scheduledDate: null,
@@ -86,7 +87,7 @@ const taskFromLine = ({ line, path }: { line: string; path: string }): Task => {
 
     const indentation: string = nonTaskMatch[1];
     const statusString: string = nonTaskMatch[3] ?? ' ';
-    const status = statusString === ' ' ? Status.Todo : Status.Done;
+    const status = StatusRegistry.getInstance().byIndicator(statusString);
     let description: string = nonTaskMatch[4];
 
     const blockLinkMatch = line.match(Task.blockLinkRegex);
@@ -101,7 +102,6 @@ const taskFromLine = ({ line, path }: { line: string; path: string }): Task => {
         description,
         path,
         indentation,
-        originalStatusCharacter: statusString,
         blockLink,
         priority: Priority.None,
         startDate: null,

src/Commands/SelectStatus.ts.txt

@@ -0,0 +1,120 @@
+// import { Editor, MarkdownView, View } from 'obsidian';
+
+// import { Task } from '../Task';
+
+// import { promptForMark } from '../ui/TaskMarkModal';
+// export const selectStatus = (checking: boolean, editor: Editor, view: View) => {
+//     const mark = await promptForMark(this.app, this.plugin);
+//     if (mark) {
+//         this.markTaskOnLines(mark, this.getCurrentLinesFromEditor(editor));
+//     }
+
+//     if (checking) {
+//         if (!(view instanceof MarkdownView)) {
+//             // If we are not in a markdown view, the command shouldn't be shown.
+//             return false;
+//         }
+
+//         // The command should always trigger in a markdown view:
+//         // - Convert lines to list items.
+//         // - Convert list items to tasks.
+//         // - Toggle tasks' status.
+//         return true;
+//     }
+
+//     if (!(view instanceof MarkdownView)) {
+//         // Should never happen due to check above.
+//         return;
+//     }
+
+//     // We are certain we are in the editor due to the check above.
+//     const path = view.file?.path;
+//     if (path === undefined) {
+//         return;
+//     }
+
+//     const cursorPosition = editor.getCursor();
+//     const lineNumber = cursorPosition.line;
+//     const line = editor.getLine(lineNumber);
+
+//     const toggledLine = toggleLine({ line, path });
+//     editor.setLine(lineNumber, toggledLine);
+
+//     // The cursor is moved to the end of the line by default.
+//     // If there is text on the line, put the cursor back where it was on the line.
+//     if (/[^ [\]*-]/.test(toggledLine)) {
+//         editor.setCursor({
+//             line: cursorPosition.line,
+//             // Need to move the cursor by the distance we added to the beginning.
+//             ch: cursorPosition.ch + toggledLine.length - line.length,
+//         });
+//     }
+// };
+
+// const toggleLine = ({ line, path }: { line: string; path: string }): string => {
+//     let toggledLine: string = line;
+
+//     const task = Task.fromLine({
+//         line,
+//         path,
+//         sectionStart: 0, // We don't need this to toggle it here in the editor.
+//         sectionIndex: 0, // We don't need this to toggle it here in the editor.
+//         precedingHeader: null, // We don't need this to toggle it here in the editor.
+//     });
+//     if (task !== null) {
+//         toggledLine = toggleTask({ task });
+//     } else {
+//         // If the task is null this means that we have one of:
+//         // 1. a regular checklist item
+//         // 2. a list item
+//         // 3. a simple text line
+
+//         // The task regex will match checklist items.
+//         const regexMatch = line.match(Task.taskRegex);
+//         if (regexMatch !== null) {
+//             toggledLine = toggleChecklistItem({ regexMatch });
+//         } else {
+//             // This is not a checklist item. It is one of:
+//             // 1. a list item
+//             // 2. a simple text line
+
+//             const listItemRegex = /^([\s\t]*)([-*])/;
+//             if (listItemRegex.test(line)) {
+//                 // Let's convert the list item to a checklist item.
+//                 toggledLine = line.replace(listItemRegex, '$1$2 [ ]');
+//             } else {
+//                 // Let's convert the line to a list item.
+//                 toggledLine = line.replace(/^([\s\t]*)/, '$1- ');
+//             }
+//         }
+//     }
+
+//     return toggledLine;
+// };
+
+// const toggleTask = ({ task }: { task: Task }): string => {
+//     // Toggle a regular task.
+//     const toggledTasks = task.toggle();
+//     const serialized = toggledTasks
+//         .map((task: Task) => task.toFileLineString())
+//         .join('\n');
+
+//     return serialized;
+// };
+
+// const toggleChecklistItem = ({
+//     regexMatch,
+// }: {
+//     regexMatch: RegExpMatchArray;
+// }): string => {
+//     // It's a checklist item, let's toggle it.
+//     const indentation = regexMatch[1];
+//     const statusString = regexMatch[2].toLowerCase();
+//     const body = regexMatch[3];
+
+//     const toggledStatusString = statusString === ' ' ? 'x' : ' ';
+
+//     const toggledLine = `${indentation}- [${toggledStatusString}] ${body}`;
+
+//     return toggledLine;
+// };

src/Commands/index.ts

@@ -1,5 +1,7 @@
 import type { App, Editor, Plugin, View } from 'obsidian';
+
 import { createOrEdit } from './CreateOrEdit';
+//import { selectStatus } from './SelectStatus';
 
 import { toggleDone } from './ToggleDone';
 
@@ -32,5 +34,12 @@ export class Commands {
             icon: 'check-in-circle',
             editorCheckCallback: toggleDone,
         });
+
+        // plugin.addCommand({
+        //     id: 'select-status-modal',
+        //     name: 'Select Status',
+        //     icon: 'check-in-circle',
+        //     editorCheckCallback: selectStatus,
+        // });
     }
 }

src/Events.ts

@@ -16,8 +16,8 @@ interface CacheUpdateData {
 export class Events {
     private obsidianEvents: ObsidianEvents;
 
-    constructor({ obsidianEents }: { obsidianEents: ObsidianEvents }) {
-        this.obsidianEvents = obsidianEents;
+    constructor({ obsidianEvents }: { obsidianEvents: ObsidianEvents }) {
+        this.obsidianEvents = obsidianEvents;
     }
 
     public onCacheUpdate(

src/Feature.ts

@@ -0,0 +1,69 @@
+export type FeatureFlag = {
+    [internalName: string]: boolean;
+};
+
+/**
+ * @todo documentation
+ *
+ * @since {date}
+ */
+export class Feature {
+    static readonly TASK_STATUS_MENU = new Feature(
+        'TASK_STATUS_MENU',
+        0,
+        'Enables a right click menu for each task to allow you to select the task Status from the available next transition states.',
+        'Task Status Menu',
+        false,
+        false,
+    );
+
+    static get values(): Feature[] {
+        return [this.TASK_STATUS_MENU];
+    }
+
+    static get settingsFlags(): FeatureFlag {
+        const featureFlags: { [internalName: string]: boolean } = {};
+
+        Feature.values.forEach((feature) => {
+            featureFlags[feature.internalName] = feature.enabledByDefault;
+        });
+        return featureFlags;
+    }
+
+    /**
+     * Converts a string to its corresponding default Feature instance.
+     *
+     * @param string the string to convert to Feature
+     * @throws RangeError, if a string that has no corresponding Feature value was passed.
+     * @returns the matching Feature
+     */
+    static fromString(string: string): Feature {
+        const value = (this as any)[string];
+        if (value) {
+            return value;
+        }
+
+        throw new RangeError(
+            `Illegal argument passed to fromString(): ${string} does not correspond to any available Feature ${
+                (this as any).prototype.constructor.name
+            }`,
+        );
+    }
+
+    private constructor(
+        public readonly internalName: string,
+        public readonly index: number,
+        public readonly description: string,
+        public readonly displayName: string,
+        public readonly enabledByDefault: boolean,
+        public readonly stable: boolean,
+    ) {}
+
+    /**
+     * Called when converting the Feature value to a string using JSON.Stringify.
+     * Compare to the fromString() method, which deserializes the object.
+     */
+    public toJSON() {
+        return this.internalName;
+    }
+}

src/Query.ts

@@ -4,7 +4,9 @@ import type { TaskGroups } from './Query/TaskGroups';
 import { getSettings } from './Settings';
 import { LayoutOptions } from './LayoutOptions';
 import { Sort } from './Sort';
-import { Priority, Status, Task } from './Task';
+import { Status } from './Status';
+import { Priority, Task } from './Task';
+import { StatusRegistry } from './StatusRegistry';
 import type { IQuery } from './IQuery';
 
 import type { Field } from './Query/Filter/Field';
@@ -65,6 +67,8 @@ export class Query implements IQuery {
     private readonly doneString = 'done';
     private readonly notDoneString = 'not done';
 
+    private readonly statusRegexp = /^status (is not|is) (.*)/;
+
     private readonly pathRegexp = /^path (includes|does not include) (.*)/;
     private readonly descriptionRegexp =
         /^description (includes|does not include) (.*)/;
@@ -107,12 +111,12 @@ export class Query implements IQuery {
                         break;
                     case line === this.doneString:
                         this._filters.push(
-                            (task) => task.status === Status.Done,
+                            (task) => task.status === Status.DONE,
                         );
                         break;
                     case line === this.notDoneString:
                         this._filters.push(
-                            (task) => task.status !== Status.Done,
+                            (task) => task.status !== Status.DONE,
                         );
                         break;
                     case line === this.recurringString:
@@ -162,6 +166,9 @@ export class Query implements IQuery {
                         break;
                     case this.parseFilter(line, new DoneDateField()):
                         break;
+                    case this.statusRegexp.test(line):
+                        this.parseStatusFilter({ line });
+                        break;
                     case this.pathRegexp.test(line):
                         this.parsePathFilter({ line });
                         break;
@@ -330,6 +337,40 @@ export class Query implements IQuery {
         }
     }
 
+    /**
+     * Parses the status query, will fail if the status is not registered.
+     * Uses the RegEx: '^status (is|is not) (.*)'
+     *
+     * @private
+     * @param {{ line: string }} { line }
+     * @return {*}  {void}
+     * @memberof Query
+     */
+    private parseStatusFilter({ line }: { line: string }): void {
+        const statusMatch = line.match(this.statusRegexp);
+        if (statusMatch !== null) {
+            const filterStatus = statusMatch[2];
+
+            if (
+                StatusRegistry.getInstance().byIndicator(filterStatus) ===
+                Status.EMPTY
+            ) {
+                this._error =
+                    'status you are searching for is not registered in configuration.';
+                return;
+            }
+
+            let filter;
+            if (statusMatch[1] === 'is') {
+                filter = (task: Task) => task.status.indicator === filterStatus;
+            } else {
+                filter = (task: Task) => task.status.indicator !== filterStatus;
+            }
+
+            this._filters.push(filter);
+        }
+    }
+
     private parsePathFilter({ line }: { line: string }): void {
         const pathMatch = line.match(this.pathRegexp);
         if (pathMatch !== null) {

src/Query/Group.ts

@@ -109,7 +109,7 @@ export class Group {
     }
 
     private static groupByStatus(task: Task): string {
-        return task.status;
+        return task.status.name;
     }
 
     private static groupByHeading(task: Task): string {