feat: go to definition

Author: pd93

README.md

@@ -6,16 +6,17 @@ This extension integrates your Taskfile into Visual Studio Code.
 
 - View tasks in the activity bar
 - Run tasks from the activity bar and command palette
+- Go to definition
 
 ## Roadmap
 
 - Run last task command
+- Stream output to output channel instead of waiting for command to finish
 - Switch between nested/flat task view
 - Refresh up-to-date status when a task's sources change
+- Status polling to update up-to-date status
 - Support global tasks
 - Support workspaces
-- Go to definitions
-- Re run last task
 - Install Task via command palette
   - Prompt if a Taskfile is detected and Task is not installed
 - If no Taskfile is detected, add a button to initialise one

package.json

@@ -53,6 +53,18 @@
         "title": "Run Task",
         "category": "Task",
         "icon": "$(play)"
+      },
+      {
+        "command": "vscode-task.goToDefinition",
+        "title": "Go to Definition",
+        "category": "Task",
+        "icon": "$(go-to-file)"
+      },
+      {
+        "command": "vscode-task.goToDefinitionPicker",
+        "title": "Go to Definition",
+        "category": "Task",
+        "icon": "$(go-to-file)"
       }
     ],
     "viewsContainers": {
@@ -77,6 +89,10 @@
         {
           "command": "vscode-task.runTask",
           "when": "false"
+        },
+        {
+          "command": "vscode-task.goToDefinition",
+          "when": "false"
         }
       ],
       "view/title": [
@@ -91,6 +107,11 @@
           "command": "vscode-task.runTask",
           "when": "view == vscode-task.tasks && viewItem == taskTreeItem",
           "group": "inline"
+        },
+        {
+          "command": "vscode-task.goToDefinition",
+          "when": "view == vscode-task.tasks && viewItem == taskTreeItem",
+          "group": "inline"
         }
       ]
     },

src/models/taskfile.ts

@@ -7,4 +7,11 @@ export interface Task {
     desc: string;
     summary: string;
     up_to_date: boolean;
+    location: Location;
+}
+
+export interface Location {
+    taskfile: string;
+    line: number;
+    column: number;
 }

src/providers/tasks.ts

@@ -26,7 +26,11 @@ export class Tasks implements vscode.TreeDataProvider<TaskTreeItem> {
             // If the task's namespace is the same as the parent's namespace
             // add the task to the tree
             if ((parent && parent.namespace === namespace) || (!parent && namespace === "")) {
-                taskTreeItems.push(new TaskTreeItem(taskLabel, namespace, task, vscode.TreeItemCollapsibleState.None));
+                taskTreeItems.push(new TaskTreeItem(taskLabel, namespace, task, vscode.TreeItemCollapsibleState.None, {
+                    command: 'vscode-task.goToDefinition',
+                    title: 'Go to Definition',
+                    arguments: [task, true],
+                }));
                 return;
             }
 
@@ -71,7 +75,8 @@ export class TaskTreeItem extends vscode.TreeItem {
         readonly label: string,
         readonly namespace: string,
         readonly task: models.Task | undefined,
-        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+        public readonly collapsibleState: vscode.TreeItemCollapsibleState,
+        public readonly command?: vscode.Command
     ) {
         super(label, collapsibleState);
         this.description = this.task?.desc;

src/services/taskfile.ts

@@ -15,36 +15,53 @@ class TaskfileService {
     }
 
     public async read(): Promise<models.Taskfile> {
-        return await new Promise((resolve, reject) => {
+        return await new Promise((resolve) => {
             let command = 'task --list-all --json';
-            cp.exec(command, { cwd: getWorkspaceFolder() }, (err: cp.ExecException | null, stdout: string, stderr: string) => {
-                if (err) {
-                    console.log('error: ' + err);
-                    reject();
-                    return;
-                }
+            cp.exec(command, { cwd: getWorkspaceFolder() }, (_, stdout: string) => {
                 var taskfile: models.Taskfile = JSON.parse(stdout);
                 resolve(taskfile);
             });
         });
     }
 
     public async runTask(taskName: string): Promise<void> {
-        return await new Promise((resolve, reject) => {
+        return await new Promise((resolve) => {
             let command = `task ${taskName}`;
-            cp.exec(command, { cwd: getWorkspaceFolder() }, (err: cp.ExecException | null, stdout: string, stderr: string) => {
-                if (err) {
-                    console.log('error: ' + err);
-                    reject();
-                    return;
-                }
+            cp.exec(command, { cwd: getWorkspaceFolder() }, (_, stdout: string, stderr: string) => {
                 TaskfileService.outputChannel.append(stderr);
                 TaskfileService.outputChannel.append(stdout);
+                TaskfileService.outputChannel.append("-----");
                 TaskfileService.outputChannel.show();
                 resolve();
             });
         });
     }
+
+    public goToDefinition(task: models.Task, preview: boolean = false): void {
+        if (task.location === undefined) {
+            vscode.window.showErrorMessage(`Go to definition requires Task v3.23.0 or higher.`);
+            return;
+        }
+
+        let position = new vscode.Position(task.location.line - 1, task.location.column - 1);
+        let range = new vscode.Range(position, position);
+
+        // Create the vscode URI from the Taskfile path
+        let file = vscode.Uri.file(task.location.taskfile);
+
+        // Create the vscode text document show options
+        let options: vscode.TextDocumentShowOptions = {
+            selection: range,
+            preview: preview
+        };
+
+        // Run the vscode open command with the range options
+        try {
+            vscode.commands.executeCommand('vscode.open', file, options);
+        } catch (err) {
+            console.error(err);
+        }
+    }
 }
 
 export const taskfile = TaskfileService.Instance;

src/task.ts

@@ -37,6 +37,11 @@ export class TaskExtension {
 
     public registerCommands(context: vscode.ExtensionContext): void {
 
+        // Refresh tasks
+        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.refresh', () => {
+            this.updateAndRefresh();
+        }));
+
         // Run task
         context.subscriptions.push(vscode.commands.registerCommand('vscode-task.runTask', (treeItem?: TaskTreeItem) => {
             if (treeItem?.task) {
@@ -46,7 +51,7 @@ export class TaskExtension {
 
         // Run task picker
         context.subscriptions.push(vscode.commands.registerCommand('vscode-task.runTaskPicker', () => {
-            if (!this._taskfile || this._taskfile.tasks.length === 0) {
+            if (this._taskfile === undefined || this._taskfile.tasks.length === 0) {
                 vscode.window.showInformationMessage('No tasks found');
                 return;
             }
@@ -57,9 +62,32 @@ export class TaskExtension {
             });
         }));
 
-        // Refresh tasks
-        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.refresh', () => {
-            this.updateAndRefresh();
+        // Go to definition
+        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.goToDefinition', (task: TaskTreeItem | models.Task, preview: boolean = false) => {
+            if (task instanceof TaskTreeItem) {
+                if (task.task === undefined) {
+                    return;
+                }
+                task = task.task;
+            }
+            services.taskfile.goToDefinition(task, preview);
+        }));
+
+        // Go to definition picker
+        context.subscriptions.push(vscode.commands.registerCommand('vscode-task.goToDefinitionPicker', () => {
+            if (this._taskfile === undefined || this._taskfile.tasks.length === 0) {
+                vscode.window.showInformationMessage('No tasks found');
+                return;
+            }
+            vscode.window.showQuickPick(this._taskfile.tasks.map(t => t.name)).then((taskName) => {
+                if (taskName) {
+                    let task = this._taskfile?.tasks.find(t => t.name === taskName);
+                    if (task === undefined) {
+                        return;
+                    }
+                    services.taskfile.goToDefinition(task);
+                }
+            });
         }));
     }