Added deferred trigger for progress badge after user open the view

Author: shinin-light

src/deepcode/lib/modules/BaseDeepCodeModule.ts

@@ -7,10 +7,12 @@ import DeepCodeFilesWatcher from "../watchers/DeepCodeFilesWatcher";
 import DeepCodeWorkspaceFoldersWatcher from "../watchers/WorkspaceFoldersWatcher";
 import DeepCodeEditorsWatcher from "../watchers/EditorsWatcher";
 import DeepCodeSettingsWatcher from "../watchers/DeepCodeSettingsWatcher";
+import { PendingTask, PendingTaskInterface } from "../../utils/pendingTask";
 import { IDE_NAME, REFRESH_VIEW_DEBOUNCE_INTERVAL } from "../../constants/general";
 import { setContext } from "../../utils/vscodeCommandsUtils";
 import { DEEPCODE_VIEW_ANALYSIS } from "../../constants/views";
 import { errorsLogs } from '../../messages/errorsServerLogMessages';
+import { pendingMocks } from 'nock/types';
 
 export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCodeModuleInterface {
   currentWorkspacePath: string;
@@ -29,8 +31,8 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
   refreshViewEmitter: vscode.EventEmitter<any>;
 	analysisStatus = '';
   analysisProgress = 0;
-  private progressBadgePromise: Promise<void> | undefined;
-  private progressBadgeResolveFn: (() => void) | undefined;
+  private initializedView: PendingTaskInterface;
+  private progressBadge: PendingTaskInterface | undefined;
   private viewContext: {[key: string]: unknown};
 
   // These attributes are used in tests
@@ -55,6 +57,7 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
     this.analysisStatus = '';
     this.analysisProgress = 0;
     this.viewContext = {};
+    this.initializedView = new PendingTask();
   }
 
   get baseURL(): string {
@@ -123,40 +126,39 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
   }
 
   private getProgressBadgePromise(): Promise<void> {
-    if (this.progressBadgePromise === undefined) {
-      // This should not be needed, but we resolve pending Promises 
-      // before overwriting the progressBadgeResolveFn reference.
-      if (this.progressBadgeResolveFn) this.progressBadgeResolveFn();
-      this.progressBadgePromise = new Promise(
-        (resolve) => {
-          this.progressBadgeResolveFn = resolve;
-        }
-      );
+    if (!this.progressBadge || this.progressBadge.isCompleted) {
+      this.progressBadge = new PendingTask();
     }
-    return this.progressBadgePromise;
+    return this.progressBadge.waiter;
   }
 
   // Leave viewId undefined to remove the badge from all views
   async setLoadingBadge(value: boolean): Promise<void> {
-    if (this.progressBadgeResolveFn) this.progressBadgeResolveFn();
     if (value) {
       // Using closure on this to allow partial binding in arbitrary positions
       const self = this;
-      vscode.window.withProgress(
-        { location: { viewId: DEEPCODE_VIEW_ANALYSIS } },
-        () => self.getProgressBadgePromise()
+      this.initializedView.waiter.then(
+        () => vscode.window.withProgress(
+          { location: { viewId: DEEPCODE_VIEW_ANALYSIS } },
+          () => self.getProgressBadgePromise()
+        )
       ).then(
         () => {},
         (error) => self.processError(error, {
           message: errorsLogs.loadingBadge,
         })
       );
     } else {
-      this.progressBadgePromise = undefined;
-      this.progressBadgeResolveFn = undefined;
+      if (this.progressBadge && !this.progressBadge.isCompleted) {
+        this.progressBadge.complete();
+      }
     }
   }
 
+  emitViewInitialized(): void {
+    if (!this.initializedView.isCompleted) this.initializedView.complete();
+  }
+
   // Avoid refreshing context/views too often:
   // https://github.com/Microsoft/vscode/issues/68424
   refreshViews = _.debounce(

src/deepcode/utils/pendingTask.ts

@@ -0,0 +1,32 @@
+export interface PendingTaskInterface {
+  waiter: Promise<void>;
+  isCompleted: boolean;
+  complete(): void;
+};
+
+export class PendingTask implements PendingTaskInterface {
+  private _promise: Promise<void>;
+  private _resolve: (() => void) | undefined;
+  private _resolved: boolean;
+
+  constructor() {
+    this._resolved = false;
+    this._promise = new Promise((resolve) => {
+      this._resolve = resolve;
+    }).then((nullValue) => {
+      this._resolved = true;
+    });
+  }
+
+  get waiter(): Promise<void> {
+    return this._promise;
+  }
+
+  get isCompleted(): boolean {
+    return this._resolved;
+  }
+
+  complete(): void {
+    if (this._resolve !== undefined) this._resolve();
+  }
+}

src/deepcode/view/IssueProvider.ts

@@ -47,6 +47,7 @@ export class IssueProvider extends NodeProvider {
   }
 
   getRootChildren(): Node[] {
+    this.extension.emitViewInitialized();
     const review: Node[] = [];
     let nIssues = 0;
     if (

src/interfaces/DeepCodeInterfaces.ts

@@ -193,6 +193,7 @@ namespace DeepCode {
     setLoadingBadge(value: boolean): Promise<void>
     setContext(key: string, value: unknown): Promise<void>;
     shouldShowAnalysis: boolean;
+    emitViewInitialized(): void;
 
     // Abstract methods
     processError(