removed notebookeditorprovider as dependency

Author: techwithtim

src/client/common/application/commands.ts

@@ -6,7 +6,7 @@
 import { CancellationToken, Position, TextDocument, Uri } from 'vscode';
 import { Commands as LSCommands } from '../../activation/languageServer/constants';
 import { Commands as DSCommands } from '../../datascience/constants';
-import { INotebook } from '../../datascience/types';
+import { INotebook, INotebookModel } from '../../datascience/types';
 import { CommandSource } from '../../testing/common/constants';
 import { TestFunction, TestsToRun } from '../../testing/common/types';
 import { TestDataItem, TestWorkspaceFolder } from '../../testing/types';
@@ -168,10 +168,10 @@ export interface ICommandNameArgumentTypeMapping extends ICommandNameWithoutArgu
     [DSCommands.RunCurrentCellAndAddBelow]: [string];
     [DSCommands.ScrollToCell]: [string, string];
     [DSCommands.ViewJupyterOutput]: [];
-    [DSCommands.ExportAsPythonScript]: [];
-    [DSCommands.ExportToHTML]: [];
-    [DSCommands.ExportToPDF]: [];
-    [DSCommands.Export]: [];
+    [DSCommands.ExportAsPythonScript]: [INotebookModel];
+    [DSCommands.ExportToHTML]: [INotebookModel];
+    [DSCommands.ExportToPDF]: [INotebookModel];
+    [DSCommands.Export]: [INotebookModel];
     [DSCommands.SwitchJupyterKernel]: [INotebook | undefined, 'raw' | 'jupyter'];
     [DSCommands.SelectJupyterCommandLine]: [undefined | Uri];
     [DSCommands.SaveNotebookNonCustomEditor]: [Uri];

src/client/datascience/commands/exportCommands.ts

@@ -10,7 +10,7 @@ import { IApplicationShell, ICommandManager } from '../../common/application/typ
 import { IDisposable } from '../../common/types';
 import { Commands } from '../constants';
 import { ExportFormat, ExportManager, IExportManager } from '../export/exportManager';
-import { INotebookEditorProvider } from '../types';
+import { INotebookModel } from '../types';
 
 interface IExportQuickPickItem extends QuickPickItem {
     handler(): void;
@@ -22,14 +22,13 @@ export class ExportCommands implements 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);
+        this.registerCommand(Commands.ExportAsPythonScript, (model) => this.export(model, ExportFormat.python));
+        this.registerCommand(Commands.ExportToHTML, (model) => this.export(model, ExportFormat.html));
+        this.registerCommand(Commands.ExportToPDF, (model) => this.export(model, ExportFormat.pdf));
+        this.registerCommand(Commands.Export, (model) => this.export(model));
     }
 
     public dispose() {
@@ -45,37 +44,31 @@ export class ExportCommands implements IDisposable {
         this.disposables.push(disposable);
     }
 
-    private async export(exportMethod?: ExportFormat) {
-        // get notebook provider
-        const model = this.notebookEditorProvider.activeEditor?.model;
-        if (!model) {
-            throw Error('No active editor found.');
-        }
-
+    private async export(model: INotebookModel, exportMethod?: ExportFormat) {
         if (exportMethod) {
             await this.exportManager.export(exportMethod, model);
         } else {
-            const pickedItem = await this.showExportQuickPickMenu().then((item) => item);
+            const pickedItem = await this.showExportQuickPickMenu(model).then((item) => item);
             if (pickedItem !== undefined) {
                 pickedItem.handler();
             }
         }
     }
 
-    private getExportQuickPickItems(): IExportQuickPickItem[] {
+    private getExportQuickPickItems(model: INotebookModel): IExportQuickPickItem[] {
         return [
             {
                 label: 'Python Script',
                 picked: true,
-                handler: () => this.commandManager.executeCommand(Commands.ExportAsPythonScript)
+                handler: () => this.commandManager.executeCommand(Commands.ExportAsPythonScript, model)
             }
             //{ 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();
+    private async showExportQuickPickMenu(model: INotebookModel): Promise<IExportQuickPickItem | undefined> {
+        const items = this.getExportQuickPickItems(model);
 
         const options: QuickPickOptions = {
             ignoreFocusOut: false,

src/client/datascience/export/exportManagerFileOpener.ts

@@ -15,7 +15,7 @@ export class ExportManagerFileOpener implements IExportManager {
     ) {}
 
     public async export(format: ExportFormat, model: INotebookModel): Promise<Uri | undefined> {
-        const reporter = this.progressReporter.createProgressIndicator(`Exporting to ${format}`); // TODO: need to localize
+        const reporter = this.progressReporter.createProgressIndicator(`Exporting to ${format}`); // need to localize
         let uri: Uri | undefined;
         try {
             uri = await this.manager.export(format, model);
@@ -25,7 +25,7 @@ export class ExportManagerFileOpener implements IExportManager {
         } finally {
             reporter.dispose();
         }
-        // maybe prompt
+        // maybe prompt before exporting
         if (format === ExportFormat.python) {
             await this.openPythonFile(uri);
         } else {

src/client/datascience/interactive-ipynb/nativeEditor.ts

@@ -684,7 +684,11 @@ export class NativeEditor extends InteractiveBase implements INotebookEditor {
     }
 
     private async exportAs(): Promise<void> {
-        this.commandManager.executeCommand(Commands.Export);
+        const activeEditor = this.editorProvider.activeEditor;
+        if (!activeEditor || !activeEditor.model) {
+            return;
+        }
+        this.commandManager.executeCommand(Commands.Export, activeEditor.model);
     }
 
     private logNativeCommand(args: INativeCommand) {

src/test/datascience/nativeEditor.functional.test.tsx

@@ -613,9 +613,11 @@ df.head()`;
                         // Click export and wait for a document to change
                         const commandFired = createDeferred();
                         const commandManager = TypeMoq.Mock.ofType<ICommandManager>();
+                        const editor = TypeMoq.Mock.ofType<INotebookEditorProvider>().object.activeEditor;
+                        const model = editor!.model!;
                         ioc.serviceManager.rebindInstance<ICommandManager>(ICommandManager, commandManager.object);
                         commandManager
-                            .setup((cmd) => cmd.executeCommand(Commands.Export))
+                            .setup((cmd) => cmd.executeCommand(Commands.Export, model))
                             .returns(() => {
                                 commandFired.resolve();
                                 return Promise.resolve();