fix: validate configurations once, instead of every key press

VSCodeVim · Jan 29, 2019 · ccbb35b · ccbb35b
1 parent fbbc1c9
commit ccbb35b
Show file tree

Hide file tree

Showing 21 changed files with 249 additions and 160 deletions.
diff --git a/extension.ts b/extension.ts
@@ -16,14 +16,13 @@ import { ModeHandler } from './src/mode/modeHandler';
 import { ModeHandlerMap } from './src/mode/modeHandlerMap';
 import { ModeName } from './src/mode/mode';
 import { Notation } from './src/configuration/notation';
+import { Logger } from './src/util/logger';
 import { Position } from './src/common/motion/position';
 import { StatusBar } from './src/statusBar';
 import { VsCodeContext } from './src/util/vscode-context';
 import { commandLine } from './src/cmd_line/commandLine';
 import { configuration } from './src/configuration/configuration';
-import { configurationValidator } from './src/configuration/configurationValidator';
 import { globalState } from './src/state/globalState';
-import { logger } from './src/util/logger';
 import { taskQueue } from './src/taskQueue';
 
 let extensionContext: vscode.ExtensionContext;
@@ -68,21 +67,38 @@ export async function getAndUpdateModeHandler(forceSyncAndUpdate = false): Promi
   return curHandler;
 }
 
+async function loadConfiguration() {
+  const configurationErrors = await configuration.load();
+  const logger = Logger.get('Configuration');
+
+  const numErrors = configurationErrors.filter(e => e.level === 'error').length;
+  logger.debug(`${numErrors} found with vim configuration`);
+
+  if (numErrors > 0) {
+    for (let configurationError of configurationErrors) {
+      switch (configurationError.level) {
+        case 'error':
+          logger.error(configurationError.message);
+          break;
+        case 'warning':
+          logger.warn(configurationError.message);
+          break;
+      }
+    }
+  }
+}
 export async function activate(context: vscode.ExtensionContext) {
-  logger.debug('Extension: activating vscodevim.');
-
   extensionContext = context;
   extensionContext.subscriptions.push(StatusBar);
 
-  logger.debug('Extension: registering event handlers.');
+  await loadConfiguration();
 
   // workspace events
   registerEventListener(
     context,
     vscode.workspace.onDidChangeConfiguration,
-    () => {
-      logger.debug('onDidChangeConfiguration: reloading configuration');
-      configuration.reload();
+    async () => {
+      await loadConfiguration();
     },
     false
   );
@@ -344,7 +360,6 @@ export async function activate(context: vscode.ExtensionContext) {
   await Promise.all([
     commandLine.load(),
     globalState.load(),
-    configurationValidator.initialize(),
     // This is called last because getAndUpdateModeHandler() will change cursor
     toggleExtension(configuration.disableExtension, compositionState),
   ]);

diff --git a/src/actions/plugins/imswitcher.ts b/src/actions/plugins/imswitcher.ts
@@ -3,7 +3,7 @@ import { Globals } from '../../globals';
 import { ModeName } from '../../mode/mode';
 import { configuration } from '../../configuration/configuration';
 import { exists } from 'fs';
-import { logger } from '../../util/logger';
+import { Logger } from '../../util/logger';
 import { promisify } from 'util';
 
 /**
@@ -14,8 +14,9 @@ export class InputMethodSwitcher {
     this.execute = execute;
   }
 
-  private savedIMKey = '';
   private execute: (cmd: string) => Promise<string>;
+  private readonly logger = Logger.get('IMSwitcher');
+  private savedIMKey = '';
 
   public async switchInputMethod(prevMode: ModeName, newMode: ModeName) {
     if (configuration.autoSwitchInputMethod.enable !== true) {
@@ -48,11 +49,11 @@ export class InputMethodSwitcher {
           this.savedIMKey = insertIMKey.trim();
         }
       } catch (e) {
-        logger.error(`IMSwitcher: Error switching to default IM. err=${e}`);
+        this.logger.error(`Error switching to default IM. err=${e}`);
       }
     } else {
-      logger.error(
-        `IMSwitcher: Unable to find ${rawObtainIMCmd}. Check your 'vim.autoSwitchInputMethod.obtainIMCmd' in VSCode setting.`
+      this.logger.error(
+        `Unable to find ${rawObtainIMCmd}. Check your 'vim.autoSwitchInputMethod.obtainIMCmd' in VSCode setting.`
       );
       this.disableIMSwitch();
     }
@@ -79,12 +80,12 @@ export class InputMethodSwitcher {
         try {
           await this.execute(switchIMCmd);
         } catch (e) {
-          logger.error(`IMSwitcher: Error switching to IM. err=${e}`);
+          this.logger.error(`Error switching to IM. err=${e}`);
         }
       }
     } else {
-      logger.error(
-        `IMSwitcher: Unable to find ${rawSwitchIMCmd}. Check your 'vim.autoSwitchInputMethod.switchIMCmd' in VSCode setting.`
+      this.logger.error(
+        `Unable to find ${rawSwitchIMCmd}. Check your 'vim.autoSwitchInputMethod.switchIMCmd' in VSCode setting.`
       );
       this.disableIMSwitch();
     }
@@ -104,27 +105,27 @@ export class InputMethodSwitcher {
   }
 
   private disableIMSwitch() {
-    logger.warn('IMSwitcher: disabling IMSwitch');
+    this.logger.warn('disabling IMSwitch');
     configuration.autoSwitchInputMethod.enable = false;
   }
 
   private isConfigurationValid(): boolean {
     let switchIMCmd = configuration.autoSwitchInputMethod.switchIMCmd;
     if (!switchIMCmd.includes('{im}')) {
-      logger.error(
-        'IMSwitcher: vim.autoSwitchInputMethod.switchIMCmd is incorrect, \
+      this.logger.error(
+        'vim.autoSwitchInputMethod.switchIMCmd is incorrect, \
         it should contain the placeholder {im}'
       );
       return false;
     }
     let obtainIMCmd = configuration.autoSwitchInputMethod.obtainIMCmd;
     if (obtainIMCmd === undefined || obtainIMCmd === '') {
-      logger.error('IMSwitcher: vim.autoSwitchInputMethod.obtainIMCmd is empty');
+      this.logger.error('vim.autoSwitchInputMethod.obtainIMCmd is empty');
       return false;
     }
     let defaultIMKey = configuration.autoSwitchInputMethod.defaultIM;
     if (defaultIMKey === undefined || defaultIMKey === '') {
-      logger.error('IMSwitcher: vim.autoSwitchInputMethod.defaultIM is empty');
+      this.logger.error('vim.autoSwitchInputMethod.defaultIM is empty');
       return false;
     }
     return true;

diff --git a/src/cmd_line/commandLine.ts b/src/cmd_line/commandLine.ts
@@ -2,14 +2,15 @@ import * as parser from './parser';
 import * as vscode from 'vscode';
 import { CommandLineHistory } from '../history/historyFile';
 import { ModeName } from './../mode/mode';
+import { Logger } from '../util/logger';
 import { StatusBar } from '../statusBar';
 import { VimError, ErrorCode } from '../error';
 import { VimState } from '../state/vimState';
 import { configuration } from '../configuration/configuration';
-import { logger } from '../util/logger';
 
 class CommandLine {
   private _history: CommandLineHistory;
+  private readonly _logger = Logger.get('CommandLine');
 
   /**
    *  Index used for navigating commandline history with <up> and <down>
@@ -78,14 +79,14 @@ class CommandLine {
           );
         }
       } else {
-        logger.error(`commandLine: Error executing cmd=${command}. err=${e}.`);
+        this._logger.error(`Error executing cmd=${command}. err=${e}.`);
       }
     }
   }
 
   public async PromptAndRun(initialText: string, vimState: VimState): Promise<void> {
     if (!vscode.window.activeTextEditor) {
-      logger.debug('commandLine: No active document');
+      this._logger.debug('No active document');
       return;
     }
     let cmd = await vscode.window.showInputBox(this.getInputBoxOptions(initialText));
@@ -103,7 +104,7 @@ class CommandLine {
 
   public async ShowHistory(initialText: string, vimState: VimState): Promise<string | undefined> {
     if (!vscode.window.activeTextEditor) {
-      logger.debug('commandLine: No active document.');
+      this._logger.debug('No active document.');
       return '';
     }
 

diff --git a/src/cmd_line/commands/file.ts b/src/cmd_line/commands/file.ts
@@ -3,9 +3,9 @@ import * as node from '../node';
 import * as path from 'path';
 import * as util from 'util';
 import * as vscode from 'vscode';
-import { logger } from '../../util/logger';
+import untildify = require('untildify');
+import { Logger } from '../../util/logger';
 
-const untildify = require('untildify');
 const doesFileExist = util.promisify(fs.exists);
 
 export enum FilePosition {
@@ -23,6 +23,7 @@ export interface IFileCommandArguments extends node.ICommandArgs {
 
 export class FileCommand extends node.CommandBase {
   protected _arguments: IFileCommandArguments;
+  private readonly _logger = Logger.get('File');
 
   constructor(args: IFileCommandArguments) {
     super();
@@ -111,7 +112,7 @@ export class FileCommand extends node.CommandBase {
           if (this._arguments.createFileIfNotExists) {
             await util.promisify(fs.close)(await util.promisify(fs.open)(filePath, 'w'));
           } else {
-            logger.error(`file: ${filePath} does not exist.`);
+            this._logger.error(`${filePath} does not exist.`);
             return;
           }
         }

diff --git a/src/cmd_line/commands/write.ts b/src/cmd_line/commands/write.ts
@@ -3,9 +3,9 @@ import * as node from '../node';
 import * as path from 'path';
 import * as util from 'util';
 import * as vscode from 'vscode';
+import { Logger } from '../../util/logger';
 import { StatusBar } from '../../statusBar';
 import { VimState } from '../../state/vimState';
-import { logger } from '../../util/logger';
 
 export interface IWriteCommandArguments extends node.ICommandArgs {
   opt?: string;
@@ -23,6 +23,7 @@ export interface IWriteCommandArguments extends node.ICommandArgs {
 //
 export class WriteCommand extends node.CommandBase {
   protected _arguments: IWriteCommandArguments;
+  private readonly _logger = Logger.get('Write');
 
   constructor(args: IWriteCommandArguments) {
     super();
@@ -36,16 +37,16 @@ export class WriteCommand extends node.CommandBase {
 
   async execute(vimState: VimState): Promise<void> {
     if (this.arguments.opt) {
-      logger.warn('write: not implemented');
+      this._logger.warn('not implemented');
       return;
     } else if (this.arguments.file) {
-      logger.warn('write: not implemented');
+      this._logger.warn('not implemented');
       return;
     } else if (this.arguments.append) {
-      logger.warn('write: not implemented');
+      this._logger.warn('not implemented');
       return;
     } else if (this.arguments.cmd) {
-      logger.warn('write: not implemented');
+      this._logger.warn('not implemented');
       return;
     }
 

diff --git a/src/cmd_line/parser.ts b/src/cmd_line/parser.ts
@@ -1,9 +1,9 @@
 import * as lexer from './lexer';
 import * as node from './node';
 import * as token from './token';
+import { Logger } from '../util/logger';
 import { VimError, ErrorCode } from '../error';
 import { commandParsers } from './subparser';
-import { logger } from '../util/logger';
 
 interface IParseFunction {
   (state: ParserState, command: node.CommandLine): IParseFunction | null;
@@ -20,6 +20,8 @@ export function parse(input: string): node.CommandLine {
 }
 
 function parseLineRange(state: ParserState, commandLine: node.CommandLine): IParseFunction | null {
+  const logger = Logger.get('Parser');
+
   while (true) {
     let tok = state.next();
     switch (tok.type) {