ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 10:58:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Nb/show notebooks as untitled (#6376)

Browse Source 
* open notebooks as untitled files and removed the saving to home directory

* return just filename without extension since save is adding the .ipynb ext

* Changes to open bdc notebooks as untitled docs. Updated tests to align with the changes

* changes: not to show untitled file as dirty and cleaned up tests in notebookService

* changes to address untitled name conflicts with open editors.

* comment cleanup
This commit is contained in:
Maddy
2019-07-16 16:00:38 -07:00
committed by GitHub
parent 095a4b17f7
commit caff76b723
9 changed files with 70 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
extensions/resource-deployment/src/services/notebookService.ts
View File

@@ -4,9 +4,10 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as vscode from 'vscode';
import * as azdata from 'azdata';
import { NotebookInfo } from '../interfaces';
import { isString } from 'util';
import * as os from 'os';
import * as path from 'path';
import * as nls from 'vscode-nls';
import { IPlatformService } from './platformService';
@@ -28,9 +29,7 @@ export class NotebookService implements INotebookService {
const notebookRelativePath = this.getNotebook(notebook);
const notebookFullPath = path.join(__dirname, '../../', notebookRelativePath);
if (notebookRelativePath && this.platformService.fileExists(notebookFullPath)) {
const targetFileName = this.getTargetNotebookFileName(notebookFullPath, os.homedir());
this.platformService.copyFile(notebookFullPath, targetFileName);
this.platformService.openFile(targetFileName);
this.showNotebookAsUntitled(notebookFullPath);
}
else {
this.platformService.showErrorMessage(localize('resourceDeployment.notebookNotFound', 'The notebook {0} does not exist', notebookFullPath));
@@ -58,22 +57,31 @@ export class NotebookService implements INotebookService {
return notebookPath;
}
/**
* Get a file name that is not already used in the target directory
* @param notebook source notebook file name
* @param targetDirectory target directory
*/
getTargetNotebookFileName(notebook: string, targetDirectory: string): string {
const notebookFileExtension = '.ipynb';
const baseName = path.basename(notebook, notebookFileExtension);
let targetFileName;
findNextUntitledEditorName(filePath: string): string {
const fileExtension = path.extname(filePath);
const baseName = path.basename(filePath, fileExtension);
let idx = 0;
let title = `${baseName}`;
do {
const suffix = idx === 0 ? '' : `-${idx}`;
targetFileName = path.join(targetDirectory, `${baseName}${suffix}${notebookFileExtension}`);
title = `${baseName}${suffix}`;
idx++;
} while (this.platformService.fileExists(targetFileName));
} while (this.platformService.isNotebookNameUsed(title));
return targetFileName;
return title;
}
showNotebookAsUntitled(notebookPath: string): void {
let targetFileName: string = this.findNextUntitledEditorName(notebookPath);
const untitledFileName: vscode.Uri = vscode.Uri.parse(`untitled:${targetFileName}`);
vscode.workspace.openTextDocument(notebookPath).then((document) => {
let initialContent = document.getText();
azdata.nb.showNotebookDocument(untitledFileName, {
connectionProfile: undefined,
preview: false,
initialContent: initialContent,
initialDirtyState: false
});
});
}
}

6
extensions/resource-deployment/src/services/platformService.ts
View File

@@ -6,6 +6,7 @@
import * as fs from 'fs';
import * as vscode from 'vscode';
import * as azdata from 'azdata';
/**
* Abstract of platform dependencies
@@ -16,6 +17,7 @@ export interface IPlatformService {
fileExists(file: string): boolean;
openFile(filePath: string): void;
showErrorMessage(message: string): void;
isNotebookNameUsed(title: string): boolean;
}
export class PlatformService implements IPlatformService {
@@ -38,4 +40,8 @@ export class PlatformService implements IPlatformService {
showErrorMessage(message: string): void {
vscode.window.showErrorMessage(message);
}
isNotebookNameUsed(title: string): boolean {
return (azdata.nb.notebookDocuments.findIndex(doc => doc.isUntitled && doc.fileName === title) > -1);
}
}

57
extensions/resource-deployment/src/test/notebookService.test.ts
View File

@@ -7,8 +7,6 @@
import * as TypeMoq from 'typemoq';
import 'mocha';
import * as path from 'path';
import * as os from 'os';
import { NotebookService } from '../services/NotebookService';
import assert = require('assert');
import { NotebookInfo } from '../interfaces';
@@ -62,59 +60,30 @@ suite('Notebook Service Tests', function (): void {
mockPlatformService.verify((service) => service.platform(), TypeMoq.Times.once());
});
test('launchNotebook', () => {
const mockPlatformService = TypeMoq.Mock.ofType<IPlatformService>();
const notebookService = new NotebookService(mockPlatformService.object);
const notebookFileName = 'mynotebook.ipynb';
const notebookPath = `./notebooks/${notebookFileName}`;
let actualSourceFile;
const expectedSourceFile = path.join(__dirname, '../../', notebookPath);
let actualTargetFile;
const expectedTargetFile = path.join(os.homedir(), notebookFileName);
mockPlatformService.setup((service) => service.platform()).returns(() => { return 'win32'; });
mockPlatformService.setup((service) => service.openFile(TypeMoq.It.isAnyString()));
mockPlatformService.setup((service) => service.fileExists(TypeMoq.It.isAnyString()))
.returns((path) => {
if (path === expectedSourceFile) {
return true;
}
return false;
});
mockPlatformService.setup((service) => service.copyFile(TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString()))
.returns((source, target) => { actualSourceFile = source; actualTargetFile = target; });
notebookService.launchNotebook(notebookPath);
mockPlatformService.verify((service) => service.copyFile(TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString()), TypeMoq.Times.once());
mockPlatformService.verify((service) => service.openFile(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
assert.equal(actualSourceFile, expectedSourceFile, 'source file is not correct');
assert.equal(actualTargetFile, expectedTargetFile, 'target file is not correct');
});
test('getTargetNotebookFileName with no name conflict', () => {
test('findNextUntitledEditorName with no name conflict', () => {
const mockPlatformService = TypeMoq.Mock.ofType<IPlatformService>();
const notebookService = new NotebookService(mockPlatformService.object);
const notebookFileName = 'mynotebook.ipynb';
const sourceNotebookPath = `./notebooks/${notebookFileName}`;
const expectedTargetFile = path.join(os.homedir(), notebookFileName);
mockPlatformService.setup((service) => service.fileExists(TypeMoq.It.isAnyString()))
const expectedTargetFile = 'mynotebook';
mockPlatformService.setup((service) => service.isNotebookNameUsed(TypeMoq.It.isAnyString()))
.returns((path) => { return false; });
const actualFileName = notebookService.getTargetNotebookFileName(sourceNotebookPath, os.homedir());
mockPlatformService.verify((service) => service.fileExists(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
const actualFileName = notebookService.findNextUntitledEditorName(sourceNotebookPath);
mockPlatformService.verify((service) => service.isNotebookNameUsed(TypeMoq.It.isAnyString()), TypeMoq.Times.once());
assert.equal(actualFileName, expectedTargetFile, 'target file name is not correct');
});
test('getTargetNotebookFileName with name conflicts', () => {
test('findNextUntitledEditorName with name conflicts', () => {
const mockPlatformService = TypeMoq.Mock.ofType<IPlatformService>();
const notebookService = new NotebookService(mockPlatformService.object);
const notebookFileName = 'mynotebook.ipynb';
const sourceNotebookPath = `./notebooks/${notebookFileName}`;
const expectedFileName = 'mynotebook-2.ipynb';
const expectedFileName = 'mynotebook-2';
const expected1stAttemptTargetFile = path.join(os.homedir(), notebookFileName);
const expected2ndAttemptTargetFile = path.join(os.homedir(), 'mynotebook-1.ipynb');
const expectedTargetFile = path.join(os.homedir(), expectedFileName);
mockPlatformService.setup((service) => service.fileExists(TypeMoq.It.isAnyString()))
const expected1stAttemptTargetFile = 'mynotebook';
const expected2ndAttemptTargetFile = 'mynotebook-1';
mockPlatformService.setup((service) => service.isNotebookNameUsed(TypeMoq.It.isAnyString()))
.returns((path) => {
// list all the possible values here and handle them
// if we only handle the expected value and return true for anything else, the test might run forever until times out
@@ -123,8 +92,8 @@ suite('Notebook Service Tests', function (): void {
}
return false;
});
const actualFileName = notebookService.getTargetNotebookFileName(sourceNotebookPath, os.homedir());
mockPlatformService.verify((service) => service.fileExists(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(3));
assert.equal(actualFileName, expectedTargetFile, 'target file name is not correct');
const actualFileName = notebookService.findNextUntitledEditorName(sourceNotebookPath);
mockPlatformService.verify((service) => service.isNotebookNameUsed(TypeMoq.It.isAnyString()), TypeMoq.Times.exactly(3));
assert.equal(actualFileName, expectedFileName, 'target file name is not correct');
});
});