refactored and simplified file watcher

Author: Arvid Paeglit

src/deepcode/DeepCodeExtension.ts

@@ -4,6 +4,8 @@ import { emitter } from '@deepcode/tsc';
 
 import { ExtensionInterface } from '../interfaces/DeepCodeInterfaces';
 import DeepCodeLib from './lib/modules/DeepCodeLib';
+import createFileWatcher from './lib/watchers/FilesWatcher';
+import { ISupportedFiles } from '@deepcode/tsc';
 
 import {
   DEEPCODE_START_COMMAND,
@@ -18,7 +20,7 @@ import {
 } from './constants/commands';
 import { openDeepcodeSettingsCommand, createDCIgnoreCommand } from './utils/vscodeCommandsUtils';
 import { errorsLogs } from './messages/errorsServerLogMessages';
-import { DEEPCODE_VIEW_SUPPORT, DEEPCODE_VIEW_ANALYSIS } from './constants/views';
+import { DEEPCODE_VIEW_SUPPORT, DEEPCODE_VIEW_ANALYSIS, DEEPCODE_ANALYSIS_STATUS } from './constants/views';
 import { SupportProvider } from './view/SupportProvider';
 import { IssueProvider } from './view/IssueProvider';
 
@@ -34,6 +36,7 @@ class DeepCodeExtension extends DeepCodeLib implements ExtensionInterface {
   }
 
   public activate(context: vscode.ExtensionContext): void {
+    emitter.on(emitter.events.supportedFilesLoaded, this.onSupportedFilesLoaded.bind(this));
     emitter.on(emitter.events.scanFilesProgress, this.onScanFilesProgress.bind(this));
     emitter.on(emitter.events.createBundleProgress, this.onCreateBundleProgress.bind(this));
     emitter.on(emitter.events.uploadBundleProgress, this.onUploadBundleProgress.bind(this));
@@ -146,6 +149,15 @@ class DeepCodeExtension extends DeepCodeLib implements ExtensionInterface {
   public deactivate(): void {
     emitter.removeAllListeners();
   }
+
+  onSupportedFilesLoaded(data: ISupportedFiles | null) {
+    this.updateStatus(DEEPCODE_ANALYSIS_STATUS.FILTERS, !!data ? 'Loaded extentions' : 'Loading supported extensions');
+
+    // Setup file watcher
+    if (!this.filesWatcher && data) {
+      this.filesWatcher = createFileWatcher(this, data);
+    }
+  }
 }
 
 export default DeepCodeExtension;

src/deepcode/constants/views.ts

@@ -26,6 +26,7 @@ export const DEEPCODE_MODE_CODES = {
 };
 
 export const DEEPCODE_ANALYSIS_STATUS = {
+  FILTERS: 'LOADING SUPPORTED extentions',
   COLLECTING: 'Collecting files',
   BUNDLING: 'Creating file bundles',
   UPLOADING: 'Uploading files',

src/deepcode/lib/modules/BaseDeepCodeModule.ts

@@ -8,8 +8,7 @@ import {
   errorType,
 } from "../../../interfaces/DeepCodeInterfaces";
 import DeepCodeAnalyzer from "../analyzer/DeepCodeAnalyzer";
-import DeepCodeStatusBarItem from "../statusBarItem/DeepCodeStatusBarItem";
-import DeepCodeFilesWatcher from "../watchers/DeepCodeFilesWatcher";
+import DeepCodeStatusBarItem from '../statusBarItem/DeepCodeStatusBarItem';
 import DeepCodeEditorsWatcher from "../watchers/EditorsWatcher";
 import DeepCodeSettingsWatcher from "../watchers/DeepCodeSettingsWatcher";
 import { PendingTask, PendingTaskInterface } from "../../utils/pendingTask";
@@ -24,31 +23,30 @@ import { IFileBundle } from '@deepcode/tsc';
 export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleInterface {
   analyzer: AnalyzerInterface;
   statusBarItem: StatusBarItemInterface;
-  filesWatcher: DeepCodeWatcherInterface;
+  filesWatcher: vscode.FileSystemWatcher;
   editorsWatcher: DeepCodeWatcherInterface;
   settingsWatcher: DeepCodeWatcherInterface;
 
   // Views and analysis progress
   refreshViewEmitter: vscode.EventEmitter<any>;
-	analysisStatus = '';
+  analysisStatus = '';
   analysisProgress = '';
   private initializedView: PendingTaskInterface;
   private progressBadge: PendingTaskInterface | undefined;
   private shouldShowProgressBadge = false;
-  private viewContext: {[key: string]: unknown};
+  private viewContext: { [key: string]: unknown };
 
   remoteBundle: IFileBundle;
+  changedFiles: Set<string> = new Set();
 
   // These attributes are used in tests
   staticToken = '';
-  staticBaseURL = '';
   defaultBaseURL = 'https://www.deepcode.ai';
   staticUploadApproved = false;
 
   constructor() {
     this.analyzer = new DeepCodeAnalyzer();
     this.statusBarItem = new DeepCodeStatusBarItem();
-    this.filesWatcher = new DeepCodeFilesWatcher();
     this.editorsWatcher = new DeepCodeEditorsWatcher();
     this.settingsWatcher = new DeepCodeSettingsWatcher();
     this.refreshViewEmitter = new vscode.EventEmitter<any>();
@@ -60,7 +58,7 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
 
   get baseURL(): string {
     // @ts-ignore */}
-    return this.staticBaseURL || vscode.workspace.getConfiguration('deepcode').get('url') || this.defaultBaseURL;
+    return vscode.workspace.getConfiguration('deepcode').get('url') || this.defaultBaseURL;
   }
 
   get termsConditionsUrl(): string {
@@ -72,7 +70,7 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
     return this.staticToken || vscode.workspace.getConfiguration('deepcode').get('token');
   }
 
-  async setToken(token: string): Promise<void>  {
+  async setToken(token: string): Promise<void> {
     this.staticToken = '';
     await vscode.workspace.getConfiguration('deepcode').update('token', token, true);
   }
@@ -82,7 +80,11 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
   }
 
   get uploadApproved(): boolean {
-    return this.staticUploadApproved || this.source !== IDE_NAME || !!(vscode.workspace.getConfiguration('deepcode').get<boolean>('uploadApproved'));
+    return (
+      this.staticUploadApproved ||
+      this.source !== IDE_NAME ||
+      !!vscode.workspace.getConfiguration('deepcode').get<boolean>('uploadApproved')
+    );
   }
 
   async setUploadApproved(value = true): Promise<void> {
@@ -110,7 +112,7 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
   }
 
   async setContext(key: string, value: unknown): Promise<void> {
-    console.log("DeepCode context", key, value);
+    console.log('DeepCode context', key, value);
     const oldValue = this.viewContext[key];
     this.viewContext[key] = value;
     await setContext(key, value);
@@ -119,10 +121,10 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
   }
 
   private trackContextChange(key: string, value: unknown, oldValue: unknown) {
-    let event = "";
+    let event = '';
     let shouldWaitForView = true;
-    let options: Record<string,any> | undefined;
-    switch(key) {
+    let options: Record<string, any> | undefined;
+    switch (key) {
       case DEEPCODE_CONTEXT.LOGGEDIN: {
         if (oldValue !== undefined) {
           if (!value && oldValue) event = TELEMETRY_EVENTS.viewLoginView;
@@ -157,21 +159,15 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
     }
     // We want to fire the event only when the user actually sees the View
     if (event) {
-      if (shouldWaitForView) this.initializedView.waiter.then(
-        () => this.processEvent(event, options)
-      );
+      if (shouldWaitForView) this.initializedView.waiter.then(() => this.processEvent(event, options));
       else this.processEvent(event, options);
     }
   }
 
   get shouldShowAnalysis(): boolean {
-    return !this.viewContext[
-      DEEPCODE_CONTEXT.ERROR
-    ] && [
-      DEEPCODE_CONTEXT.LOGGEDIN,
-      DEEPCODE_CONTEXT.APPROVED,
-    ].every(
-      (c) => !!this.viewContext[c]
+    return (
+      !this.viewContext[DEEPCODE_CONTEXT.ERROR] &&
+      [DEEPCODE_CONTEXT.LOGGEDIN, DEEPCODE_CONTEXT.APPROVED].every(c => !!this.viewContext[c])
     );
   }
 
@@ -189,17 +185,19 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
     if (value) {
       // Using closure on this to allow partial binding in arbitrary positions
       const self = this;
-      this.initializedView.waiter.then(
-        () => 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,
-        })
-      );
+        .then(
+          () => {},
+          error =>
+            self.processError(error, {
+              message: errorsLogs.loadingBadge,
+            }),
+        );
     } else {
       if (this.progressBadge && !this.progressBadge.isCompleted) {
         this.progressBadge.complete();
@@ -216,18 +214,12 @@ export default abstract class BaseDeepCodeModule implements BaseDeepCodeModuleIn
   refreshViews = _.throttle(
     (content?: any): void => this.refreshViewEmitter.fire(content || undefined),
     REFRESH_VIEW_DEBOUNCE_INTERVAL,
-    { 'leading': true }
+    { leading: true },
   );
 
-  abstract processError(
-    error: errorType,
-    options?: { [key: string]: any }
-  ): Promise<void>;
+  abstract processError(error: errorType, options?: { [key: string]: any }): Promise<void>;
 
-  abstract processEvent(
-    event: string,
-    options?: { [key: string]: any }
-  ): Promise<void>;
+  abstract processEvent(event: string, options?: { [key: string]: any }): Promise<void>;
 
   abstract startExtension(): Promise<void>;
 }

src/deepcode/lib/modules/BundlesModule.ts

@@ -9,9 +9,7 @@ import { errorsLogs } from "../../messages/errorsServerLogMessages";
 
 import { analyzeFolders } from '@deepcode/tsc';
 
-abstract class BundlesModule extends LoginModule
-  implements BundlesModuleInterface {
-
+abstract class BundlesModule extends LoginModule implements BundlesModuleInterface {
   runningAnalysis = false;
 
   files: string[] = [];
@@ -37,9 +35,9 @@ abstract class BundlesModule extends LoginModule
     this.updateStatus(DEEPCODE_ANALYSIS_STATUS.UPLOADING, `${processed}/${total}`);
   }
 
-  onAnalyseProgress(data: { status: string, progress: number }) {
+  onAnalyseProgress(data: { status: string; progress: number }) {
     // console.log(`ANALYSE PROGRESS - ${data.progress}`);
-    this.updateStatus(DEEPCODE_ANALYSIS_STATUS.ANALYZING, `${Math.round(100*data.progress)}%`);
+    this.updateStatus(DEEPCODE_ANALYSIS_STATUS.ANALYZING, `${Math.round(100 * data.progress)}%`);
   }
 
   onError(error: Error) {
@@ -60,16 +58,7 @@ abstract class BundlesModule extends LoginModule
         if (this.runningAnalysis) return;
         this.runningAnalysis = true;
 
-        // this.filesWatcher.activate(this);
-
-        // const removedFiles = (this.files || []).filter(f => !bundle.includes(f));
-
-        const result = await analyzeFolders(this.baseURL, this.token, false, 1, paths).catch(
-          // no need to wait for processError since catch is called asynchronously as well
-          (error) => this.processError(error, {
-            message: errorsLogs.analyse
-          })
-        );
+        const result = await analyzeFolders(this.baseURL, this.token, false, 1, paths);
 
         if (result) {
           this.remoteBundle = result;
@@ -83,7 +72,7 @@ abstract class BundlesModule extends LoginModule
       } else {
         await this.setContext(DEEPCODE_CONTEXT.WORKSPACE_FOUND, false);
       }
-    } catch(err) {
+    } catch (err) {
       await this.processError(err, {
         message: errorsLogs.failedAnalysis,
       });

src/deepcode/lib/modules/DeepCodeLib.ts

@@ -1,7 +1,7 @@
 import * as _ from "lodash";
 import { DeepCodeLibInterface } from "../../../interfaces/DeepCodeInterfaces";
 import BundlesModule from "./BundlesModule";
-import { DEEPCODE_CONTEXT, DEEPCODE_MODE_CODES } from "../../constants/views";
+import { DEEPCODE_CONTEXT, DEEPCODE_MODE_CODES } from '../../constants/views';
 import { errorsLogs } from "../../messages/errorsServerLogMessages";
 import {
   EXECUTION_DEBOUNCE_INTERVAL,
@@ -46,7 +46,6 @@ export default class DeepCodeLib extends BundlesModule implements DeepCodeLibInt
     }
     await this.setContext(DEEPCODE_CONTEXT.LOGGEDIN, true);
 
-
     const uploadApproved = await this.checkApproval();
     if (!uploadApproved) {
       return;
@@ -59,9 +58,8 @@ export default class DeepCodeLib extends BundlesModule implements DeepCodeLibInt
       this.resetTransientErrors();
       await this.setLoadingBadge(false);
       await this.startAnalysis();
-
     } catch (err) {
-      console.log('failed debounced function')
+      console.log('failed debounced function');
       await this.processError(err, {
         message: errorsLogs.failedExecutionDebounce,
       });
@@ -70,11 +68,7 @@ export default class DeepCodeLib extends BundlesModule implements DeepCodeLibInt
 
   // This function is called by commands, error handlers, etc.
   // We should avoid having duplicate parallel executions.
-  public startExtension = _.debounce(
-    this.startExtension_.bind(this),
-    EXECUTION_DEBOUNCE_INTERVAL,
-    { leading: true },
-    );
+  public startExtension = _.debounce(this.startExtension_.bind(this), EXECUTION_DEBOUNCE_INTERVAL, { leading: true });
 
   async setMode(mode: string): Promise<void> {
     if (!Object.values(DEEPCODE_MODE_CODES).includes(mode)) return;