Dynamically show progress only for the active client workspace

Author: Xanewok

CHANGELOG.md

@@ -1,5 +1,6 @@
 ### Unreleased
 
+* Dynamically show progress only for the active client workspace
 * Correctly run tasks based on active text editor rather than last opened Rust file
 * (!) Don't immediately try to start server instance for newly added workspace folders
 * Use smooth, universally supported spinner in the status bar ⚙️

src/extension.ts

@@ -30,6 +30,7 @@ import { checkForRls, ensureToolchain, rustupUpdate } from './rustup';
 import { startSpinner, stopSpinner } from './spinner';
 import { activateTaskProvider, Execution, runRlsCommand } from './tasks';
 import { withWsl } from './utils/child_process';
+import { Observable, Observer } from './utils/observable';
 import { nearestParentWorkspace } from './utils/workspace';
 import { uriWindowsToWsl, uriWslToWindows } from './utils/wslpath';
 
@@ -102,15 +103,32 @@ function whenOpeningTextDocument(document: TextDocument) {
   clientWorkspaceForUri(document.uri, { startIfMissing: true });
 }
 
+/** Tracks dynamically updated progress for the active client workspace for UI purposes. */
+const progressObserver: Observer<{ message: string } | null> = new Observer();
+
 function onDidChangeActiveTextEditor(editor: TextEditor | undefined) {
   if (!editor) {
     return;
   }
 
   const workspace = clientWorkspaceForUri(editor.document.uri);
-  if (workspace) {
-    activeWorkspace = workspace;
+  if (!workspace) {
+    return;
   }
+
+  activeWorkspace = workspace;
+
+  const updateProgress = (progress: { message: string } | null) => {
+    if (progress) {
+      startSpinner(`[${workspace.folder.name}] ${progress.message}`);
+    } else {
+      stopSpinner(`[${workspace.folder.name}]`);
+    }
+  };
+
+  progressObserver.bind(activeWorkspace.progress, updateProgress);
+  // Update UI ourselves immediately and don't wait for value update callbacks
+  updateProgress(activeWorkspace.progress.value);
 }
 
 function whenChangingWorkspaceFolders(e: WorkspaceFoldersChangeEvent) {
@@ -159,21 +177,26 @@ function clientWorkspaceForUri(
 // (VSCode workspace, not Cargo workspace). This class contains all the per-client
 // and per-workspace stuff.
 class ClientWorkspace {
+  public readonly folder: WorkspaceFolder;
   // FIXME(#233): Don't only rely on lazily initializing it once on startup,
   // handle possible `rust-client.*` value changes while extension is running
   private readonly config: RLSConfiguration;
   private lc: LanguageClient | null = null;
-  private readonly folder: WorkspaceFolder;
   private disposables: Disposable[];
+  private _progress: Observable<{ message: string } | null>;
+  get progress() {
+    return this._progress;
+  }
 
   constructor(folder: WorkspaceFolder) {
     this.config = RLSConfiguration.loadFromWorkspace(folder.uri.fsPath);
     this.folder = folder;
     this.disposables = [];
+    this._progress = new Observable<{ message: string } | null>(null);
   }
 
   public async start() {
-    startSpinner('Starting');
+    this._progress.value = { message: 'Starting' };
 
     const serverOptions: ServerOptions = async () => {
       await this.autoUpdate();
@@ -274,7 +297,6 @@ class ClientWorkspace {
 
     const runningProgress: Set<string> = new Set();
     await this.lc.onReady();
-    stopSpinner();
 
     this.lc.onNotification(
       new NotificationType<ProgressParams, void>('window/progress'),
@@ -293,9 +315,9 @@ class ClientWorkspace {
           } else if (progress.title) {
             status = `[${progress.title.toLowerCase()}]`;
           }
-          startSpinner(status);
+          this._progress.value = { message: status };
         } else {
-          stopSpinner();
+          this._progress.value = null;
         }
       },
     );

src/utils/observable.ts

@@ -0,0 +1,69 @@
+/**
+ * A wrapper around a value of type `T` that can be subscribed to whenever the
+ * underlying value changes.
+ */
+export class Observable<T> {
+  private _listeners: Set<(arg: T) => void> = new Set();
+  private _value: T;
+  /** Returns the current value. */
+  get value() {
+    return this._value;
+  }
+  /** Every change to the value triggers all the registered callbacks. */
+  set value(value: T) {
+    this._value = value;
+    this._listeners.forEach(fn => fn(value));
+  }
+
+  constructor(value: T) {
+    this._value = value;
+  }
+
+  /**
+   * Registers a listener function that's called whenever the underlying value
+   * changes.
+   * @returns a function that unregisters the listener when called.
+   */
+  public observe(fn: (arg: T) => void): () => void {
+    this._listeners.add(fn);
+
+    return () => this._listeners.delete(fn);
+  }
+}
+
+/**
+ * Capable of observing an `Observable<T>` type.
+ *
+ * Convenient when using a single observer that potentially binds multiple times
+ * to different observables, where it automatically unregisters from previous
+ * observables.
+ */
+// tslint:disable-next-line: max-classes-per-file
+export class Observer<T> {
+  private _observable?: Observable<T>;
+  private _stopObserving?: () => void;
+  /** Returns the current value of a bound observable, if there is one. */
+  get value() {
+    return this._observable && this._observable.value;
+  }
+  /**
+   * Binds to an observable value, along with the provided listener that's
+   * called whenever the underlying value changes.
+   */
+  public bind(observable: Observable<T>, handler: (arg: T) => void) {
+    this.stop();
+
+    this._observable = observable;
+    this._stopObserving = observable.observe(handler);
+  }
+  /** Unbinds from the observable, deregistering the previously bound callback. */
+  public stop() {
+    if (this._stopObserving) {
+      this._stopObserving();
+      delete this._stopObserving;
+    }
+    if (this._observable) {
+      delete this._observable;
+    }
+  }
+}