feat: refresh when taskfile is changed

Author: pd93

README.md

@@ -11,7 +11,6 @@ This extension integrates your Taskfile into Visual Studio Code.
 
 - Run last task command
 - Switch between nested/flat task view
-- Refresh tasks when Taskfile is changed
 - Refresh up-to-date status when a task's sources change
 - Support global tasks
 - Support workspaces

package.json

@@ -125,7 +125,27 @@
           "highContrastLight": "#AAAAAA"
         }
       }
-    ]
+    ],
+    "configuration": {
+      "title": "Task configuration",
+      "properties": {
+        "task": {
+          "type": "object",
+          "description": "Task configuration options.",
+          "properties": {
+            "updateOn": {
+              "type": "string",
+              "enum": [
+                "save",
+                "manual"
+              ],
+              "default": "save",
+              "description": "When the list of tasks should be updated."
+            }
+          }
+        }
+      }
+    }
   },
   "scripts": {
     "vscode:prepublish": "yarn run compile",

src/extension.ts

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

src/settings.ts

@@ -0,0 +1,24 @@
+import * as vscode from 'vscode';
+
+
+export class Settings {
+
+    constructor() {
+        this.update();
+    }
+
+    // Variables
+    public updateOn!: string;
+
+    // Fetches all the settings from the workspace configuration file
+    public update() {
+        // Get the workspace config
+        let config = vscode.workspace.getConfiguration("task");
+
+        // Get the configs
+        let updateOn: string | undefined = config.get("updateOn");
+
+        // Set the configs
+        this.updateOn = updateOn !== undefined ? updateOn : "change";
+    }
+}

src/task.ts

@@ -3,13 +3,18 @@ import * as elements from './elements';
 import * as services from './services';
 import * as models from './models';
 import { TaskTreeItem } from './providers/tasks';
+import { Settings } from './settings';
 
 export class TaskExtension {
     private _taskfile?: models.Taskfile;
+    private _settings: Settings;
     private _activityBar: elements.ActivityBar;
+    private _watcher: vscode.FileSystemWatcher;
 
     constructor() {
+        this._settings = new Settings();
         this._activityBar = new elements.ActivityBar();
+        this._watcher = vscode.workspace.createFileSystemWatcher("**/*.{yml,yaml}");
     }
 
     public async update(): Promise<void> {
@@ -22,6 +27,14 @@ export class TaskExtension {
         this._activityBar.refresh(this._taskfile);
     }
 
+    public async updateAndRefresh(): Promise<void> {
+        await this.update().then(() => {
+            this.refresh();
+        }).catch((err: string) => {
+            console.error(err);
+        });
+    }
+
     public registerCommands(context: vscode.ExtensionContext): void {
 
         // Run task
@@ -46,11 +59,30 @@ export class TaskExtension {
 
         // Refresh tasks
         context.subscriptions.push(vscode.commands.registerCommand('vscode-task.refresh', () => {
-            this.update().then(() => {
-                this.refresh();
-            }).catch((err: string) => {
-                console.error(err);
-            });
+            this.updateAndRefresh();
         }));
     }
+
+    public registerListeners(context: vscode.ExtensionContext): void {
+        // When a file on the system is changed, created or deleted
+        this._watcher.onDidChange(async _ => { await this._onDidTaskfileChange(); });
+        this._watcher.onDidCreate(async _ => { await this._onDidTaskfileChange(); });
+        this._watcher.onDidDelete(async _ => { await this._onDidTaskfileChange(); });
+
+        // Listen for configuration changes
+        vscode.workspace.onDidChangeConfiguration(event => { this._onDidChangeConfiguration(event); });
+    }
+
+    private async _onDidTaskfileChange() {
+        // If manual updating is turned off (update on save)
+        if (this._settings.updateOn !== "manual") {
+            await this.updateAndRefresh();
+        }
+    }
+
+    private _onDidChangeConfiguration(event: vscode.ConfigurationChangeEvent) {
+        if (event.affectsConfiguration("task")) {
+            this._settings.update();
+        }
+    }
 }