Handle python notebook creation

Author: misha-db

packages/databricks-vscode/src/workspace-fs/WorkspaceFsCommands.test.ts

@@ -1,5 +1,5 @@
 import assert from "assert";
-import {EventEmitter, TreeView} from "vscode";
+import {EventEmitter, TreeView, Uri, window, workspace} from "vscode";
 import {mock, instance, when} from "ts-mockito";
 import {WorkspaceFsCommands} from "./WorkspaceFsCommands";
 import {WorkspaceFsEntity} from "../sdk-extensions";
@@ -134,7 +134,7 @@ describe("WorkspaceFsCommands – target folder resolution", () => {
         });
 
         it("no element → targets root", async () => {
-            await commands.createFile(undefined);
+            await commands.createFile(makeEntity(ROOT_PATH));
             assert.strictEqual(capturedRootPath, ROOT_PATH);
         });
 
@@ -243,3 +243,107 @@ describe("WorkspaceFsCommands – target folder resolution", () => {
         });
     });
 });
+
+describe("WorkspaceFsCommands – createFile content", () => {
+    const ROOT_PATH = "/Users/me";
+
+    let commands: WorkspaceFsCommands;
+    let capturedCreate: {path: string; content: string} | undefined;
+
+    // Stubbed globals are restored after each test.
+    let originalShowInputBox: typeof window.showInputBox;
+    let originalShowTextDocument: typeof window.showTextDocument;
+    let originalOpenTextDocument: typeof workspace.openTextDocument;
+    let originalFromPath: typeof WorkspaceFsEntity.fromPath;
+
+    let inputName: string;
+
+    beforeEach(() => {
+        const mockConnectionManager = mock<ConnectionManager>();
+        when(mockConnectionManager.workspaceClient).thenReturn({} as any);
+
+        // createDirWizard reads activeProjectUri to seed the input box.
+        const mockWorkspaceFolderManager = mock<WorkspaceFolderManager>();
+        when(mockWorkspaceFolderManager.activeProjectUri).thenReturn(
+            Uri.file("/tmp/project")
+        );
+
+        commands = new WorkspaceFsCommands(
+            instance(mockWorkspaceFolderManager),
+            instance(mockConnectionManager),
+            instance(mock<WorkspaceFsDataProvider>()),
+            instance(mock<WorkspaceFsFileSystemProvider>()),
+            new FakeTreeView() as unknown as TreeView<WorkspaceFsEntity>
+        );
+
+        // Fake root that captures what doCreateFile writes.
+        capturedCreate = undefined;
+        const fakeRoot = {
+            path: ROOT_PATH,
+            createFile: async (path: string, content: string) => {
+                capturedCreate = {path, content};
+            },
+        };
+        (commands as any).getValidRoot = async () => fakeRoot;
+
+        // createDirWizard reads the filename from showInputBox.
+        originalShowInputBox = window.showInputBox;
+        (window as any).showInputBox = async () => inputName;
+
+        // No pre-existing file → skip the overwrite prompt.
+        originalFromPath = WorkspaceFsEntity.fromPath;
+        (WorkspaceFsEntity as any).fromPath = async () => undefined;
+
+        // Avoid actually opening an editor after creation.
+        originalShowTextDocument = window.showTextDocument;
+        (window as any).showTextDocument = async () => undefined;
+        originalOpenTextDocument = workspace.openTextDocument;
+        (workspace as any).openTextDocument = async (uri: Uri) => uri;
+    });
+
+    afterEach(() => {
+        (window as any).showInputBox = originalShowInputBox;
+        (window as any).showTextDocument = originalShowTextDocument;
+        (workspace as any).openTextDocument = originalOpenTextDocument;
+        (WorkspaceFsEntity as any).fromPath = originalFromPath;
+    });
+
+    it(".ipynb file is created with valid empty notebook JSON", async () => {
+        inputName = "notebook.ipynb";
+        await commands.createFile(makeEntity(ROOT_PATH));
+
+        assert.ok(capturedCreate, "createFile should have been called");
+        assert.strictEqual(capturedCreate!.path, "notebook.ipynb");
+
+        const parsed = JSON.parse(capturedCreate!.content);
+        assert.deepStrictEqual(parsed.cells, []);
+        assert.strictEqual(parsed.nbformat, 4);
+        assert.strictEqual(parsed.nbformat_minor, 5);
+        assert.strictEqual(parsed.metadata.language_info.name, "python");
+    });
+
+    it(".IPYNB extension is matched case-insensitively", async () => {
+        inputName = "NoteBook.IPYNB";
+        await commands.createFile(makeEntity(ROOT_PATH));
+
+        assert.ok(capturedCreate);
+        const parsed = JSON.parse(capturedCreate!.content);
+        assert.strictEqual(parsed.nbformat, 4);
+    });
+
+    it(".py file is created with empty content", async () => {
+        inputName = "script.py";
+        await commands.createFile(makeEntity(ROOT_PATH));
+
+        assert.ok(capturedCreate);
+        assert.strictEqual(capturedCreate!.content, "");
+    });
+
+    it("plain file is created with empty content", async () => {
+        inputName = "notes.txt";
+        await commands.createFile(makeEntity(ROOT_PATH));
+
+        assert.ok(capturedCreate);
+        assert.strictEqual(capturedCreate!.content, "");
+    });
+});

packages/databricks-vscode/src/workspace-fs/WorkspaceFsCommands.ts

@@ -16,6 +16,29 @@ import {WorkspaceFsFile} from "../sdk-extensions/wsfs/WorkspaceFsFile";
 
 const withLogContext = logging.withLogContext;
 
+/**
+ * Minimal valid empty Python notebook (nbformat 4.5) used as the initial
+ * content when creating a `.ipynb` file, so it can be opened as a notebook
+ * right away instead of as an invalid/empty document.
+ */
+const EMPTY_IPYNB_CONTENT = JSON.stringify(
+    {
+        cells: [],
+        metadata: {
+            kernelspec: {
+                display_name: "Python 3",
+                language: "python",
+                name: "python3",
+            },
+            language_info: {name: "python"},
+        },
+        nbformat: 4,
+        nbformat_minor: 5,
+    },
+    null,
+    1
+);
+
 export class WorkspaceFsCommands implements Disposable {
     private disposables: Disposable[] = [];
 
@@ -202,8 +225,12 @@ export class WorkspaceFsCommands implements Disposable {
             }
         }
 
+        const content = inputName.toLowerCase().endsWith(".ipynb")
+            ? EMPTY_IPYNB_CONTENT
+            : "";
+
         try {
-            await root.createFile(inputName, "", true);
+            await root.createFile(inputName, content, true);
         } catch (e: unknown) {
             const msg = e instanceof Error ? e.message : String(e);
             window.showErrorMessage(`Failed to create "${inputName}": ${msg}`);