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

20
extensions/mssql/src/main.ts
View File

@@ -340,17 +340,21 @@ async function handleOpenNotebookTask(profile: azdata.IConnectionProfile): Promi
}
async function handleOpenClusterStatusNotebookTask(profile: azdata.IConnectionProfile, appContext: AppContext): Promise<void> {
const notebookRelativePath = 'notebooks/tsg/cluster-status.ipynb';
const notebookFullPath = path.join(appContext.extensionContext.extensionPath, notebookRelativePath);
const notebookRelativePath: string = 'notebooks/tsg/cluster-status.ipynb';
const notebookFullPath: string = path.join(appContext.extensionContext.extensionPath, notebookRelativePath);
if (!Utils.fileExists(notebookFullPath)) {
vscode.window.showErrorMessage(localize("fileNotFound", "Unable to find the file specified"));
} else {
const targetFile = Utils.getTargetFileName(notebookFullPath);
Utils.copyFile(notebookFullPath, targetFile);
let fileUri = vscode.Uri.file(targetFile);
await azdata.nb.showNotebookDocument(fileUri, {
connectionProfile: profile,
preview: false
const title: string = Utils.findNextUntitledEditorName(notebookFullPath);
const untitledFileName: vscode.Uri = vscode.Uri.parse(`untitled:${title}`);
vscode.workspace.openTextDocument(notebookFullPath).then((document) => {
let initialContent = document.getText();
azdata.nb.showNotebookDocument(untitledFileName, {
connectionProfile: profile,
preview: true,
initialContent: initialContent,
initialDirtyState: false
});
});
}
}

11
extensions/mssql/src/utils.ts
View File

@@ -35,19 +35,18 @@ export function getAppDataPath() {
* @param filePath source notebook file name
* @param fileExtension file type
*/
export function getTargetFileName(filePath: string): string {
const targetDirectory = os.homedir();
export function findNextUntitledEditorName(filePath: string): string {
const fileExtension = path.extname(filePath);
const baseName = path.basename(filePath, fileExtension);
let targetFileName;
let idx = 0;
let title = `${baseName}`;
do {
const suffix = idx === 0 ? '' : `-${idx}`;
targetFileName = path.join(targetDirectory, `${baseName}${suffix}${fileExtension}`);
title = `${baseName}${suffix}`;
idx++;
} while (fs.existsSync(targetFileName));
} while (azdata.nb.notebookDocuments.findIndex(doc => doc.isUntitled && doc.fileName === title) > -1);
return targetFileName;
return title;
}
export function fileExists(file: string): boolean {

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');
});
});

5
src/sql/azdata.proposed.d.ts vendored
View File

@@ -4485,6 +4485,11 @@ declare module 'azdata' {
* Optional content used to give an initial notebook state
*/
initialContent?: nb.INotebookContents | string;
/**
* A optional boolean value indicating the dirty state after the intial content is loaded, default value is true
*/
initialDirtyState?: boolean;
}
/**

3
src/sql/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.ts
View File

@@ -460,6 +460,9 @@ export class MainThreadNotebookDocumentsAndEditors extends Disposable implements
let untitledModel = await input.textInput.resolve();
await untitledModel.load();
input.untitledEditorModel = untitledModel;
if (options.initialDirtyState === false) {
input.untitledEditorModel.setDirty(false);
}
}
let editor = await this._editorService.openEditor(input, editorOptions, viewColumnToEditorGroup(this._editorGroupService, options.position));
if (!editor) {

1
src/sql/workbench/api/node/extHostNotebookDocumentsAndEditors.ts
View File

@@ -206,6 +206,7 @@ export class ExtHostNotebookDocumentsAndEditors implements ExtHostNotebookDocume
options.initialContent = showOptions.initialContent;
}
}
options.initialDirtyState = showOptions.initialDirtyState;
}
let id = await this._proxy.$tryShowNotebookDocument(uri, options);
let editor = this.getEditor(id);

1
src/sql/workbench/api/node/sqlExtHost.protocol.ts
View File

@@ -908,6 +908,7 @@ export interface INotebookShowOptions {
connectionProfile?: azdata.IConnectionProfile;
defaultKernel?: azdata.nb.IKernelSpec;
initialContent?: string;
initialDirtyState?: boolean;
}
export interface ExtHostNotebookDocumentsAndEditorsShape {