Fixed lint suggestions.

Author: shinin-light

src/deepcode/lib/modules/BaseDeepCodeModule.ts

@@ -6,33 +6,31 @@ import DeepCodeFilesWatcher from "../watchers/DeepCodeFilesWatcher";
 import DeepCodeWorkspaceFoldersWatcher from "../watchers/WorkspaceFoldersWatcher";
 import DeepCodeEditorsWatcher from "../watchers/EditorsWatcher";
 import DeepCodeSettingsWatcher from "../watchers/DeepCodeSettingsWatcher";
-// import DeepCodeErrorhandler from "../errorHandler/DeepCodeErrorHandler";
 import { IDE_NAME } from "../../constants/general";
 
 export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCodeModuleInterface {
-  public currentWorkspacePath: string;
-  public workspacesPaths: Array<string>;
-  public hashesBundles: DeepCode.HashesBundlesInterface;
-  public serverFilesFilterList: DeepCode.AllowedServerFilterListInterface;
-  public remoteBundles: DeepCode.RemoteBundlesCollectionInterface;
-  public analyzer: DeepCode.AnalyzerInterface;
-  public statusBarItem: DeepCode.StatusBarItemInterface;
-  public filesWatcher: DeepCode.DeepCodeWatcherInterface;
-  public workspacesWatcher: DeepCode.DeepCodeWatcherInterface;
-  public editorsWatcher: DeepCode.DeepCodeWatcherInterface;
-  public settingsWatcher: DeepCode.DeepCodeWatcherInterface;
-  // public errorHandler: DeepCode.ErrorHandlerInterface;
+  currentWorkspacePath: string;
+  workspacesPaths: Array<string>;
+  hashesBundles: DeepCode.HashesBundlesInterface;
+  serverFilesFilterList: DeepCode.AllowedServerFilterListInterface;
+  remoteBundles: DeepCode.RemoteBundlesCollectionInterface;
+  analyzer: DeepCode.AnalyzerInterface;
+  statusBarItem: DeepCode.StatusBarItemInterface;
+  filesWatcher: DeepCode.DeepCodeWatcherInterface;
+  workspacesWatcher: DeepCode.DeepCodeWatcherInterface;
+  editorsWatcher: DeepCode.DeepCodeWatcherInterface;
+  settingsWatcher: DeepCode.DeepCodeWatcherInterface;
 
   // Views and analysis progress
-  public refreshViewEmitter: vscode.EventEmitter<any>;
-	public analysisStatus: string = '';
-  public analysisProgress: number = 0;
+  refreshViewEmitter: vscode.EventEmitter<any>;
+	analysisStatus = '';
+  analysisProgress = 0;
 
   // These attributes are used in tests
-  public staticToken = '';
-  public staticBaseURL = '';
-  public defaultBaseURL = 'https://www.deepcode.ai';
-  public staticUploadApproved = false;
+  staticToken = '';
+  staticBaseURL = '';
+  defaultBaseURL = 'https://www.deepcode.ai';
+  staticUploadApproved = false;
 
   constructor() {
     this.currentWorkspacePath = "";
@@ -46,52 +44,51 @@ export default abstract class BaseDeepCodeModule implements DeepCode.BaseDeepCod
     this.workspacesWatcher = new DeepCodeWorkspaceFoldersWatcher();
     this.editorsWatcher = new DeepCodeEditorsWatcher();
     this.settingsWatcher = new DeepCodeSettingsWatcher();
-    // this.errorHandler = new DeepCodeErrorhandler();
     this.refreshViewEmitter = new vscode.EventEmitter<any>();
     this.analysisStatus = '';
     this.analysisProgress = 0;
   }
 
-  public get baseURL(): string {
+  get baseURL(): string {
     // @ts-ignore */}
     return this.staticBaseURL || vscode.workspace.getConfiguration('deepcode').get('url') || this.defaultBaseURL;
   }
 
-  public get termsConditionsUrl(): string {
+  get termsConditionsUrl(): string {
     return `${this.baseURL}/tc?utm_source=vsc`;
   }
 
-  public get token(): string {
+  get token(): string {
     // @ts-ignore */}
     return this.staticToken || vscode.workspace.getConfiguration('deepcode').get('token');
   }
 
-  public async setToken(token: string): Promise<void>  {
+  async setToken(token: string): Promise<void>  {
     this.staticToken = '';
     await vscode.workspace.getConfiguration('deepcode').update('token', token, true);
   }
 
-  public get source(): string {
+  get source(): string {
     return process.env['GITPOD_WORKSPACE_ID'] ? 'gitpod' : IDE_NAME;
   }
 
-  public get uploadApproved(): boolean {
+  get uploadApproved(): boolean {
     return this.staticUploadApproved || this.source !== IDE_NAME || !!(vscode.workspace.getConfiguration('deepcode').get('uploadApproved'));
   }
 
-  public async setUploadApproved(value: boolean = true): Promise<void> {
+  async setUploadApproved(value = true): Promise<void> {
     await vscode.workspace.getConfiguration('deepcode').update('uploadApproved', value, true);
   }
 
-  public get shouldReportErrors(): boolean {
+  get shouldReportErrors(): boolean {
     return !!vscode.workspace.getConfiguration('deepcode').get('yesCrashReport');
   }
 
-  public get shouldReportEvents(): boolean {
+  get shouldReportEvents(): boolean {
     return !!vscode.workspace.getConfiguration('deepcode').get('yesTelemetry');
   }
 
-  public refreshViews(content?: any): void {
+  refreshViews(content?: any): void {
     this.refreshViewEmitter.fire(content || undefined);
   }
 

src/deepcode/lib/modules/DeepCodeLib.ts

@@ -18,9 +18,9 @@ export default class DeepCodeLib extends BundlesModule implements DeepCode.DeepC
     console.log("DeepCode: starting execution pipeline");
     setContext(DEEPCODE_CONTEXT.ERROR, false);
 
-    let loggedIn = await this.checkSession();
+    const loggedIn = await this.checkSession();
     if (!loggedIn) return;
-    let approved = await this.checkApproval();
+    const approved = await this.checkApproval();
     if (!approved) return;
     await this.startAnalysis();
 

src/deepcode/lib/modules/LoginModule.ts

@@ -3,14 +3,14 @@ import DeepCode from "../../../interfaces/DeepCodeInterfaces";
 import http from "../../http/requests";
 import { setContext, viewInBrowser } from "../../utils/vscodeCommandsUtils";
 import { DEEPCODE_CONTEXT } from "../../constants/views";
-
+import { errorsLogs } from "../../messages/errorsServerLogMessages";
 
 const sleep = (duration: number) => new Promise(resolve => setTimeout(resolve, duration));
 
 abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleInterface {
   private pendingLogin: boolean = false;
 
-  public async initiateLogin(): Promise<void> {
+  async initiateLogin(): Promise<void> {
     if (this.pendingLogin) {
       return;
     }
@@ -19,21 +19,21 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
     try {
       setContext(DEEPCODE_CONTEXT.LOGGEDIN, false);
       const result = await http.login(this.baseURL, this.source);
-      let { sessionToken, loginURL } = result;
+      const { sessionToken, loginURL } = result;
       if (!sessionToken || !loginURL) {
-        throw new Error(`Failed to create a new session with response: ${JSON.stringify(result)}`);
+        throw new Error(errorsLogs.login);
       }
       await this.setToken(sessionToken);
       await viewInBrowser(loginURL);
       await this.waitLoginConfirmation();
     } catch (err) {
-      await this.processError(err);
+      await this.processError(err, { message: errorsLogs.login });
     } finally {
       this.pendingLogin = false;
     }
   }
 
-  public async checkSession(): Promise<boolean> {
+  async checkSession(): Promise<boolean> {
     let validSession = false;
     if (this.token) {
       validSession = !!(await http.checkSession(this.baseURL, this.token));
@@ -55,13 +55,13 @@ abstract class LoginModule extends ReportModule implements DeepCode.LoginModuleI
     }
   }
 
-  public async checkApproval(): Promise<boolean> {
-    let approved = this.uploadApproved;
+  async checkApproval(): Promise<boolean> {
+    const approved = this.uploadApproved;
     setContext(DEEPCODE_CONTEXT.APPROVED, approved);
     return approved;
   }
 
-  public async approveUpload(): Promise<void> {
+  async approveUpload(): Promise<void> {
     this.setUploadApproved(true);
     this.checkApproval();
   } 

src/deepcode/lib/modules/ReportModule.ts

@@ -18,11 +18,11 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
     return this.baseURL === this.defaultBaseURL;
   }
 
-  public resetTransientErrors(): void {
+  resetTransientErrors(): void {
     this.transientErrors = 0;
   }
 
-  public async sendError(options: {[key: string]: any}): Promise<void> {
+  async sendError(options: {[key: string]: any}): Promise<void> {
     if (!this.shouldReport || !this.shouldReportErrors) return;
     await http.sendError(this.baseURL, {
       source: this.source,
@@ -31,7 +31,7 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
     });
   }
 
-  public async sendEvent(event: string, options: {[key: string]: any}): Promise<void> {
+  async sendEvent(event: string, options: {[key: string]: any}): Promise<void> {
     if (!this.shouldReport || !this.shouldReportEvents) return;
     await http.sendEvent(this.baseURL, {
       type: event,
@@ -41,7 +41,7 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
     });
   }
 
-  public async processError(
+  async processError(
     error: DeepCode.errorType,
     options: { [key: string]: any } = {}
   ): Promise<void> {
@@ -117,7 +117,7 @@ abstract class ReportModule extends BaseDeepCodeModule implements DeepCode.Repor
     try {
       type = `${error.statusCode || ""} ${error.name || ""}`.trim();
     } catch (e) {
-      type = "unknown"
+      type = "unknown";
     }
     try {
       await this.sendError({

src/deepcode/utils/packageUtils.ts

@@ -12,7 +12,7 @@ import { ALLOWED_PAYLOAD_SIZE } from "../constants/general";
 const SAFE_PAYLOAD_SIZE = ALLOWED_PAYLOAD_SIZE / 2;
 
 interface ProgressInterface {
-  onProgress: (value: number) => void,
+  onProgress: (value: number) => void;
   percentDone?: number;
   multiplier?: number;
 }
@@ -125,4 +125,4 @@ export const getBaseExclusionFilter = (): ExclusionFilter => {
   rootExclusionRule.addExclusions(EXCLUDED_NAMES, "");
   exclusionFilter.addExclusionRule(rootExclusionRule);
   return exclusionFilter;
-}
+};

src/deepcode/utils/vscodeCommandsUtils.ts

@@ -15,11 +15,11 @@ export const startDeepCodeCommand = (): void => {
   vscode.commands.executeCommand(DEEPCODE_START_COMMAND);
 };
 
-export function setContext(key: string, value: unknown) {
+export const setContext = (key: string, value: unknown): void => {
   console.log("DeepCode context",key, value);
   vscode.commands.executeCommand('setContext', `${DEEPCODE_CONTEXT_PREFIX}${key}`, value);
 };
 
-export function viewInBrowser(url: string) {
+export const viewInBrowser = (url: string): void => {
   vscode.commands.executeCommand(DEEPCODE_OPEN_BROWSER, url);
 };

src/deepcode/view/IssueProvider.ts

@@ -1,11 +1,11 @@
 import { Uri, Range, Diagnostic } from 'vscode';
-import { NodeProvider } from './NodeProvider'
-import { Node } from './Node'
+import { NodeProvider } from './NodeProvider';
+import { Node } from './Node';
 import { getDeepCodeSeverity } from "../utils/analysisUtils";
 import { DEEPCODE_SEVERITIES } from "../constants/analysis";
 
 interface ISeverityCounts {
-  [severity: number]: number,
+  [severity: number]: number;
 }
 
 export class IssueProvider extends NodeProvider {
@@ -14,13 +14,13 @@ export class IssueProvider extends NodeProvider {
   }
 
   getSuperscriptNumber(n: number): string {
-    let res: string = "";
+    let res = "";
     const nDigits = Math.round(n).toString().split('');
     const digitMap: { [digit: string]: string } = {
       '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
       '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹',
-    }
-    for (let d of nDigits) res += digitMap[d] || "";
+    };
+    for (const d of nDigits) res += digitMap[d] || "";
     return res;
   }
 
@@ -38,7 +38,7 @@ export class IssueProvider extends NodeProvider {
 
   getFileText(text: string, counts: ISeverityCounts ): string {
     let res :string = "";
-    for (let s of [
+    for (const s of [
       DEEPCODE_SEVERITIES.error,
       DEEPCODE_SEVERITIES.warning,
       DEEPCODE_SEVERITIES.information,

src/deepcode/view/Node.ts

@@ -2,17 +2,17 @@ import { Uri, Range, Command, TreeItem, TreeItemCollapsibleState } from 'vscode'
 import { DEEPCODE_OPEN_BROWSER, DEEPCODE_OPEN_LOCAL } from "../constants/commands";
 
 export interface INodeOptions {
-  text: string,
-  description?: string,
+  text: string;
+  description?: string;
   issue?: {
     uri: Uri,
     range?: Range,
-  },
-  link?: string,
-  command?: Command,
-  collapsed?: TreeItemCollapsibleState,
-  parent?: Node,
-  children?: Node[],
+  };
+  link?: string;
+  command?: Command;
+  collapsed?: TreeItemCollapsibleState;
+  parent?: Node;
+  children?: Node[];
 }
 
 

src/deepcode/view/NodeProvider.ts

@@ -1,11 +1,11 @@
 import DeepCode from "../../interfaces/DeepCodeInterfaces";
 import { TreeDataProvider, ProviderResult } from 'vscode';
-import { Node } from './Node'
+import { Node } from './Node';
 
 export abstract class NodeProvider implements TreeDataProvider<Node> {
   constructor(
     protected extension: DeepCode.ExtensionInterface
-  ) {};
+  ) {}
 
   abstract getRootChildren(): Node[];
 

src/deepcode/view/ProgressProvider.ts

@@ -1,5 +1,5 @@
-import { NodeProvider } from './NodeProvider'
-import { Node } from './Node'
+import { NodeProvider } from './NodeProvider';
+import { Node } from './Node';
 
 export class ProgressProvider extends NodeProvider {