refactoring and working on dependency checks

Author: techwithtim

src/client/datascience/export/exportCommands.ts

@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { QuickPickItem, QuickPickOptions } from 'vscode';
+import { ICommandNameArgumentTypeMapping } from '../../common/application/commands';
+import { IApplicationShell, ICommandManager } from '../../common/application/types';
+import { IDisposable } from '../../common/types';
+import { Commands } from '../constants';
+import { INotebookEditorProvider } from '../types';
+import { ExportFormat, ExportManager, IExportManager } from './exportManager';
+
+interface IExportQuickPickItem extends QuickPickItem {
+    handler(): void;
+}
+
+@injectable()
+export class ExportCommands implements IDisposable {
+    private readonly disposables: IDisposable[] = [];
+    constructor(
+        @inject(ICommandManager) private readonly commandManager: ICommandManager,
+        @inject(IExportManager) private exportManager: ExportManager,
+        @inject(INotebookEditorProvider) private notebookEditorProvider: INotebookEditorProvider,
+        @inject(IApplicationShell) private readonly applicationShell: IApplicationShell
+    ) {}
+    public register() {
+        this.registerCommand(Commands.ExportAsPythonScript, () => this.export(ExportFormat.python));
+        this.registerCommand(Commands.ExportToHTML, () => this.export(ExportFormat.html));
+        this.registerCommand(Commands.ExportToPDF, () => this.export(ExportFormat.pdf));
+        this.registerCommand(Commands.Export, this.export);
+    }
+
+    public dispose() {
+        this.disposables.forEach((d) => d.dispose());
+    }
+
+    private registerCommand<
+        E extends keyof ICommandNameArgumentTypeMapping,
+        U extends ICommandNameArgumentTypeMapping[E]
+        // tslint:disable-next-line: no-any
+    >(command: E, callback: (...args: U) => any) {
+        const disposable = this.commandManager.registerCommand(command, callback, this);
+        this.disposables.push(disposable);
+    }
+
+    private async export(exportMethod?: ExportFormat) {
+        // get notebook provider
+        const activeEditor = this.notebookEditorProvider.activeEditor;
+        if (!activeEditor) {
+            throw Error('No active editor found.');
+        }
+
+        if (exportMethod) {
+            await this.exportManager.export(exportMethod, activeEditor);
+        } else {
+            // if no method was provided display quick pick menu
+            const pickedItem = await this.showExportQuickPickMenu().then((item) => item);
+            if (pickedItem !== undefined) {
+                pickedItem.handler();
+            }
+        }
+    }
+
+    private getExportQuickPickItems(): IExportQuickPickItem[] {
+        return [
+            {
+                label: 'Python Script',
+                picked: true,
+                handler: () => this.commandManager.executeCommand(Commands.ExportAsPythonScript)
+            }
+            //{ label: 'HTML', picked: false, handler: () => this.commandManager.executeCommand(Commands.ExportToHTML) },
+            //{ label: 'PDF', picked: false, handler: () => this.commandManager.executeCommand(Commands.ExportToPDF) }
+        ];
+    }
+
+    private async showExportQuickPickMenu(): Promise<IExportQuickPickItem | undefined> {
+        const items = this.getExportQuickPickItems();
+
+        const options: QuickPickOptions = {
+            ignoreFocusOut: false,
+            matchOnDescription: true,
+            matchOnDetail: true,
+            placeHolder: 'Export As...'
+        };
+
+        return this.applicationShell.showQuickPick(items, options);
+    }
+}

src/client/datascience/export/exportManager.ts

@@ -92,7 +92,7 @@ export class ExportManager implements IExportManager {
         return tempFile;
     }
 
-    private getFileSaveLocation(): Uri {
+    private getLastFileSaveLocation(): Uri {
         const filePath = this.workspaceStorage.get(
             ExportNotebookSettings.lastSaveLocation,
             this.defaultExportSaveLocation
@@ -126,7 +126,7 @@ export class ExportManager implements IExportManager {
         }
 
         const options: SaveDialogOptions = {
-            defaultUri: this.getFileSaveLocation(),
+            defaultUri: this.getLastFileSaveLocation(),
             saveLabel: '',
             filters: fileExtensions
         };
@@ -139,31 +139,6 @@ export class ExportManager implements IExportManager {
     }
 }
 
-@injectable()
-export class ExportManagerDependencyChecker implements IExportManager {
-    constructor(@inject(ExportManager) private readonly manager: IExportManager) {}
-
-    public async export(format: ExportFormat, activeEditor: INotebookEditor): Promise<Uri | undefined> {
-        // CHekc dependnecies.. etc.
-
-        // if not ok return.
-        // Else export.
-        return this.manager.export(format, activeEditor);
-    }
-}
-
-@injectable()
-export class ExportManagerFileOpener implements IExportManager {
-    constructor(@inject(ExportManagerDependencyChecker) private readonly manager: IExportManager) {}
-
-    public async export(format: ExportFormat, activeEditor: INotebookEditor): Promise<Uri | undefined> {
-        const uri = await this.manager.export(format, activeEditor);
-
-        // open the file.
-        return uri;
-    }
-}
-// make new command registry, move stuff from old
 // continue with decorater pattern - READ
 // ts mockito - READ
 // do depenedncy checking using code seen before

src/client/datascience/export/exportManagerDependencyChecker.ts

@@ -0,0 +1,28 @@
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import * as localize from '../../common/utils/localize';
+import { IJupyterExecution, IJupyterInterpreterDependencyManager, INotebookEditor } from '../types';
+import { ExportFormat, ExportManager, IExportManager } from './exportManager';
+
+@injectable()
+export class ExportManagerDependencyChecker implements IExportManager {
+    constructor(
+        @inject(ExportManager) private readonly manager: IExportManager,
+        @inject(IJupyterExecution) private jupyterExecution: IJupyterExecution,
+        @inject(IJupyterInterpreterDependencyManager)
+        private readonly dependencyManager: IJupyterInterpreterDependencyManager
+    ) {}
+
+    public async export(format: ExportFormat, activeEditor: INotebookEditor): Promise<Uri | undefined> {
+        // Before we try the import, see if we don't support it, if we don't give a chance to install dependencies
+        if (!(await this.jupyterExecution.isImportSupported())) {
+            await this.dependencyManager.installMissingDependencies();
+        }
+
+        if (await this.jupyterExecution.isImportSupported()) {
+            return this.manager.export(format, activeEditor);
+        } else {
+            throw new Error(localize.DataScience.jupyterNbConvertNotSupported());
+        }
+    }
+}

src/client/datascience/export/exportManagerFileOpener.ts

@@ -0,0 +1,17 @@
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { INotebookEditor } from '../types';
+import { ExportFormat, IExportManager } from './exportManager';
+import { ExportManagerDependencyChecker } from './exportManagerDependencyChecker';
+
+@injectable()
+export class ExportManagerFileOpener implements IExportManager {
+    constructor(@inject(ExportManagerDependencyChecker) private readonly manager: IExportManager) {}
+
+    public async export(format: ExportFormat, activeEditor: INotebookEditor): Promise<Uri | undefined> {
+        const uri = await this.manager.export(format, activeEditor);
+
+        // open the file.
+        return uri;
+    }
+}

src/client/datascience/serviceRegistry.ts

@@ -34,7 +34,9 @@ import { CodeWatcher } from './editor-integration/codewatcher';
 import { Decorator } from './editor-integration/decorator';
 import { HoverProvider } from './editor-integration/hoverProvider';
 import { DataScienceErrorHandler } from './errorHandler/errorHandler';
-import { ExportFormat, ExportManager, ExportManagerDependencyChecker, IExport, IExportManager } from './export/exportManager';
+import { ExportCommands } from './export/exportCommands';
+import { ExportFormat, ExportManager, IExport, IExportManager } from './export/exportManager';
+import { ExportManagerDependencyChecker } from './export/exportManagerDependencyChecker';
 import { ExportToHTML } from './export/exportToHTML';
 import { ExportToPDF } from './export/exportToPDF';
 import { ExportToPython } from './export/exportToPython';
@@ -273,6 +275,7 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IExport>(IExport, ExportToPDF, ExportFormat.pdf);
     serviceManager.addSingleton<IExport>(IExport, ExportToHTML, ExportFormat.html);
     serviceManager.addSingleton<IExport>(IExport, ExportToPython, ExportFormat.python);
+    serviceManager.addSingleton<ExportCommands>(ExportCommands, ExportCommands);
 
     registerGatherTypes(serviceManager);
     registerNotebookTypes(serviceManager);