Command wrapping is done in the adaptor

Author: ryu1kn

src/lib/adaptors/command.ts

@@ -1,5 +1,7 @@
 import * as vscode from 'vscode';
 import CommandWrapper from '../command-wrapper';
+import {Command} from '../commands/command';
+import {Logger} from '../types/logger';
 
 type UriParser = (uri: string) => vscode.Uri;
 
@@ -8,16 +10,18 @@ export type CommandType = 'TEXT_EDITOR' | 'GENERAL';
 export interface CommandItem {
     name: string;
     type: CommandType;
-    command: CommandWrapper;
+    command: Command;
 }
 
 export default class CommandAdaptor {
     private readonly commands: typeof vscode.commands;
     private readonly parseUri: UriParser;
+    private readonly logger: Logger;
 
-    constructor(commands: typeof vscode.commands, parseUri: UriParser) {
+    constructor(commands: typeof vscode.commands, parseUri: UriParser, logger: Logger) {
         this.commands = commands;
         this.parseUri = parseUri;
+        this.logger = logger;
     }
 
     async executeCommand(name: string, uri1: string, uri2: string, title: string): Promise<{}> {
@@ -26,7 +30,8 @@ export default class CommandAdaptor {
 
     registerCommand(cmd: CommandItem): vscode.Disposable {
         const registerer = this.getCommandRegisterer(cmd.type);
-        return registerer(cmd.name, cmd.command.execute, cmd.command);
+        const command = new CommandWrapper(cmd.command, this.logger);
+        return registerer(cmd.name, command.execute, command);
     }
 
     private getCommandRegisterer(commandType: CommandType) {

src/lib/bootstrapper-factory.ts

@@ -15,7 +15,7 @@ export default class BootstrapperFactory {
         const logger = console;
         const selectionInfoRegistry = new SelectionInfoRegistry();
         const workspaceAdaptor = new WorkspaceAdaptor(vscode.workspace);
-        const commandAdaptor = new CommandAdaptor(vscode.commands, vscode.Uri.parse);
+        const commandAdaptor = new CommandAdaptor(vscode.commands, vscode.Uri.parse, logger);
         const normalisationRuleStore = new NormalisationRuleStore(workspaceAdaptor);
         const commandFactory = new CommandFactory(
             selectionInfoRegistry,
@@ -26,6 +26,6 @@ export default class BootstrapperFactory {
             () => new Date()
         );
         const contentProvider = new ContentProvider(selectionInfoRegistry, normalisationRuleStore);
-        return new Bootstrapper(commandFactory, contentProvider, workspaceAdaptor, commandAdaptor, logger);
+        return new Bootstrapper(commandFactory, contentProvider, workspaceAdaptor, commandAdaptor);
     }
 }

src/lib/bootstrapper.ts

@@ -2,9 +2,6 @@ import CommandFactory from './command-factory';
 import ContentProvider from './content-provider';
 import {EXTENSION_NAMESPACE, EXTENSION_SCHEME} from './const';
 import {ExecutionContextLike} from './types/vscode';
-import CommandWrapper from './command-wrapper';
-import {Logger} from './types/logger';
-import {Command} from './commands/command';
 import WorkspaceAdaptor from './adaptors/workspace';
 import CommandAdaptor, {CommandItem} from './adaptors/command';
 
@@ -13,18 +10,15 @@ export default class Bootstrapper {
     private readonly contentProvider: ContentProvider;
     private readonly workspaceAdaptor: WorkspaceAdaptor;
     private readonly commandAdaptor: CommandAdaptor;
-    private readonly logger: Logger;
 
     constructor(commandFactory: CommandFactory,
                 contentProvider: ContentProvider,
                 workspaceAdaptor: WorkspaceAdaptor,
-                commandAdaptor: CommandAdaptor,
-                logger: Logger) {
+                commandAdaptor: CommandAdaptor) {
         this.commandFactory = commandFactory;
         this.contentProvider = contentProvider;
         this.workspaceAdaptor = workspaceAdaptor;
         this.commandAdaptor = commandAdaptor;
-        this.logger = logger;
     }
 
     initiate(context: ExecutionContextLike) {
@@ -52,32 +46,28 @@ export default class Bootstrapper {
             {
                 name: `${EXTENSION_NAMESPACE}.diffVisibleEditors`,
                 type: 'GENERAL',
-                command: this.wrapCommand(this.commandFactory.createCompareVisibleEditorsCommand())
+                command: this.commandFactory.createCompareVisibleEditorsCommand()
             },
             {
                 name: `${EXTENSION_NAMESPACE}.markSection1`,
                 type: 'TEXT_EDITOR',
-                command: this.wrapCommand(this.commandFactory.crateSaveText1Command())
+                command: this.commandFactory.crateSaveText1Command()
             },
             {
                 name: `${EXTENSION_NAMESPACE}.markSection2AndTakeDiff`,
                 type: 'TEXT_EDITOR',
-                command: this.wrapCommand(this.commandFactory.createCompareSelectionWithText1Command())
+                command: this.commandFactory.createCompareSelectionWithText1Command()
             },
             {
                 name: `${EXTENSION_NAMESPACE}.diffSelectionWithClipboard`,
                 type: 'TEXT_EDITOR',
-                command: this.wrapCommand(this.commandFactory.createCompareSelectionWithClipboardCommand())
+                command: this.commandFactory.createCompareSelectionWithClipboardCommand()
             },
             {
                 name: `${EXTENSION_NAMESPACE}.togglePreComparisonTextNormalizationRules`,
                 type: 'GENERAL',
-                command: this.wrapCommand(this.commandFactory.createToggleNormalisationRulesCommand())
+                command: this.commandFactory.createToggleNormalisationRulesCommand()
             }
         ];
     }
-
-    private wrapCommand(command: Command) {
-        return new CommandWrapper(command, this.logger);
-    }
 }