feat: add view to activity bar

Author: pd93

package.json

@@ -17,6 +17,50 @@
         "command": "vscode-task.runTask",
         "title": "Run Task",
         "category": "Task"
+      },
+      {
+        "command": "vscode-task.refreshTasks",
+        "title": "Refresh Tasks",
+        "category": "Task"
+      }
+    ],
+    "viewsContainers": {
+      "activitybar": [
+        {
+          "id": "vscode-task",
+          "title": "Task",
+          "icon": "./res/task.svg"
+        }
+      ]
+    },
+    "views": {
+      "vscode-task": [
+        {
+          "id": "vscode-task.tasks",
+          "name": "Tasks"
+        }
+      ]
+    },
+    "colors": [
+      {
+        "id": "vscodetask.upToDate",
+        "description": "Color for up-to-date tasks in the activity bar.",
+        "defaults": {
+          "dark": "#00AA00",
+          "light": "#00AA00",
+          "highContrast": "#00AA00",
+          "highContrastLight": "#00AA00"
+        }
+      },
+      {
+        "id": "vscodetask.outOfDate",
+        "description": "Color for out-of-date tasks in the activity bar.",
+        "defaults": {
+          "dark": "#AAAAAA",
+          "light": "#AAAAAA",
+          "highContrast": "#AAAAAA",
+          "highContrastLight": "#AAAAAA"
+        }
       }
     ]
   },

src/elements/activityBar.ts

@@ -0,0 +1,22 @@
+import * as vscode from 'vscode';
+import * as providers from '../providers';
+import * as models from '../models';
+
+export class ActivityBar {
+    private _provider: providers.Tasks;
+
+    constructor() {
+        // Create the data provider
+        this._provider = new providers.Tasks();
+
+        // Register the tree view with its data provider
+        vscode.window.createTreeView('vscode-task.tasks', {
+            treeDataProvider: this._provider,
+            showCollapseAll: true
+        });
+    }
+
+    public refresh(taskfile?: models.Taskfile) {
+        this._provider.refresh(taskfile);
+    }
+}

src/elements/index.ts

@@ -0,0 +1 @@
+export * from './activityBar';

src/extension.ts

@@ -10,7 +10,9 @@ export function activate(context: vscode.ExtensionContext) {
 	taskExtension.registerCommands(context);
 
 	// Refresh the tasks list
-	taskExtension.update().catch((err: string) => {
+	taskExtension.update().then(() => {
+		taskExtension.refresh();
+	}).catch((err: string) => {
 		console.error(err);
 	});
 }

src/providers/index.ts

@@ -0,0 +1 @@
+export * from './tasks';

src/providers/tasks.ts

@@ -0,0 +1,41 @@
+import * as vscode from 'vscode';
+import * as models from '../models';
+
+export class Tasks implements vscode.TreeDataProvider<TaskTreeItem> {
+    private _onDidChangeTreeData: vscode.EventEmitter<TaskTreeItem | undefined> = new vscode.EventEmitter<TaskTreeItem | undefined>();
+    readonly onDidChangeTreeData: vscode.Event<TaskTreeItem | undefined> = this._onDidChangeTreeData.event;
+    private _taskfile?: models.Taskfile;
+
+    getTreeItem(element: TaskTreeItem): vscode.TreeItem {
+        return element;
+    }
+
+    getChildren(element?: TaskTreeItem): Thenable<TaskTreeItem[]> {
+        var taskTreeItems: TaskTreeItem[] = [];
+        this._taskfile?.tasks.forEach(task => {
+            taskTreeItems.push(new TaskTreeItem(task, vscode.TreeItemCollapsibleState.None));
+        });
+        return Promise.resolve(taskTreeItems);
+    }
+
+    refresh(taskfile?: models.Taskfile): void {
+        this._taskfile = taskfile;
+        this._onDidChangeTreeData.fire(undefined);
+    }
+}
+
+class TaskTreeItem extends vscode.TreeItem {
+    constructor(
+        private task: models.Task,
+        public readonly collapsibleState: vscode.TreeItemCollapsibleState
+    ) {
+        super(task.name, collapsibleState);
+        this.tooltip = `${this.task.desc}`;
+        this.description = this.task.desc;
+        if (this.task.up_to_date) {
+            this.iconPath = new vscode.ThemeIcon('debug-breakpoint-log-unverified', new vscode.ThemeColor('vscodetask.upToDate'));
+        } else {
+            this.iconPath = new vscode.ThemeIcon('debug-breakpoint-data-unverified', new vscode.ThemeColor('vscodetask.outOfDate'));
+        }
+    }
+}

src/services/taskfile.ts

@@ -17,7 +17,7 @@ class TaskfileService {
     public async read(): Promise<models.Taskfile> {
         return await new Promise((resolve, reject) => {
             let command = 'task --list-all --json';
-            cp.exec(command, (err: cp.ExecException | null, stdout: string, stderr: string) => {
+            cp.exec(command, { cwd: getWorkspaceFolder() }, (err: cp.ExecException | null, stdout: string, stderr: string) => {
                 if (err) {
                     console.log('error: ' + err);
                     reject();
@@ -32,7 +32,7 @@ class TaskfileService {
     public async runTask(taskName: string): Promise<void> {
         return await new Promise((resolve, reject) => {
             let command = `task ${taskName}`;
-            cp.exec(command, (err: cp.ExecException | null, stdout: string, stderr: string) => {
+            cp.exec(command, { cwd: getWorkspaceFolder() }, (err: cp.ExecException | null, stdout: string, stderr: string) => {
                 if (err) {
                     console.log('error: ' + err);
                     reject();
@@ -48,3 +48,10 @@ class TaskfileService {
 }
 
 export const taskfile = TaskfileService.Instance;
+
+function getWorkspaceFolder(): string | undefined {
+    if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
+        return undefined;
+    }
+    return vscode.workspace.workspaceFolders[0].uri.path;
+}

src/task.ts

@@ -1,23 +1,35 @@
 import * as vscode from 'vscode';
 import * as commands from './commands';
+import * as elements from './elements';
 import * as services from './services';
 import * as models from './models';
 
 export class TaskExtension {
     private _taskfile?: models.Taskfile;
+    private _activityBar: elements.ActivityBar;
+
+    constructor() {
+        this._activityBar = new elements.ActivityBar();
+    }
 
     public async update(): Promise<void> {
         await services.taskfile.read().then((taskfile: models.Taskfile) => {
             this._taskfile = taskfile;
         });
     }
 
+    public refresh(): void {
+        this._activityBar.refresh(this._taskfile);
+    }
+
     public registerCommands(context: vscode.ExtensionContext): void {
         context.subscriptions.push(vscode.commands.registerCommand('vscode-task.runTask', () => {
             commands.runTask(this._taskfile);
         }));
         context.subscriptions.push(vscode.commands.registerCommand('vscode-task.refreshTasks', () => {
-            this.update().catch((err: string) => {
+            this.update().then(() => {
+                this.refresh();
+            }).catch((err: string) => {
                 console.error(err);
             });
         }));