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

Add support for new version of Jupyter Book (#12086)

Browse Source 
* Add support for new jupyter book version

* Add changes to the jupyter notebook to create books

* Create config file

* Add support of new version of jupyter book on ADS

* Fix paths for opening folder with v1 and v2 books

* Add tests for jupyter book v2

* Update tests

* Fix tests

* Fix get parent issue

* Address PR comments

* Fix bookVersion condition in getSections and fix issue on create book notebook

* Fix search

* update python notebook

* Remove commented lines
This commit is contained in:
Barbara Valdez
2020-09-10 11:32:58 -07:00
committed by GitHub
parent ff61eae164
commit 3ff9df8e0b
6 changed files with 959 additions and 582 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
extensions/notebook/src/book/bookModel.ts
View File

@@ -5,22 +5,30 @@
import * as vscode from 'vscode';
import * as yaml from 'js-yaml';
import { BookTreeItem, BookTreeItemType } from './bookTreeItem';
import { BookTreeItem, BookTreeItemType, BookTreeItemFormat } from './bookTreeItem';
import * as constants from '../common/constants';
import * as path from 'path';
import * as fileServices from 'fs';
import * as fs from 'fs-extra';
import * as loc from '../common/localizedConstants';
import { IJupyterBookToc, IJupyterBookSection } from '../contracts/content';
import { IJupyterBookToc, JupyterBookSection, IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';
const fsPromises = fileServices.promises;
const content = 'content';
export enum BookVersion {
v1 = 'v1',
v2 = 'v2'
}
export class BookModel {
private _bookItems: BookTreeItem[];
private _allNotebooks = new Map<string, BookTreeItem>();
private _tableOfContentsPath: string;
private _contentFolderPath: string;
private _configPath: string;
private _bookVersion: BookVersion;
private _rootPath: string;
private _errorMessage: string;
constructor(
@@ -37,11 +45,38 @@ export class BookModel {
if (this.isNotebook) {
this.readNotebook();
} else {
await this.loadTableOfContentFiles(this.bookPath);
await this.readBookStructure(this.bookPath);
await this.loadTableOfContentFiles();
await this.readBooks();
}
}
public async readBookStructure(folderPath: string): Promise<void> {
// check book structure to determine version
let isOlderVersion: boolean;
this._configPath = path.posix.join(folderPath, '_config.yml');
try {
isOlderVersion = (await fs.stat(path.posix.join(folderPath, '_data'))).isDirectory() && (await fs.stat(path.posix.join(folderPath, content))).isDirectory();
} catch {
isOlderVersion = false;
}
if (isOlderVersion) {
let isTocFile = (await fs.stat(path.posix.join(folderPath, '_data', 'toc.yml'))).isFile();
if (isTocFile) {
this._tableOfContentsPath = path.posix.join(folderPath, '_data', 'toc.yml');
}
this._bookVersion = BookVersion.v1;
this._contentFolderPath = path.posix.join(folderPath, content, '');
this._rootPath = path.dirname(path.dirname(this._tableOfContentsPath));
} else {
this._contentFolderPath = folderPath;
this._tableOfContentsPath = path.posix.join(folderPath, '_toc.yml');
this._rootPath = path.dirname(this._tableOfContentsPath);
this._bookVersion = BookVersion.v2;
}
}
public getAllNotebooks(): Map<string, BookTreeItem> {
return this._allNotebooks;
}
@@ -50,14 +85,12 @@ export class BookModel {
return this._allNotebooks.get(this.openAsUntitled ? path.basename(uri) : uri);
}
public async loadTableOfContentFiles(folderPath: string): Promise<void> {
public async loadTableOfContentFiles(): Promise<void> {
if (this.isNotebook) {
return;
}
let tableOfContentsPath: string = path.posix.join(folderPath, '_data', 'toc.yml');
if (await fs.pathExists(tableOfContentsPath)) {
this._tableOfContentsPath = tableOfContentsPath;
if (await fs.pathExists(this._tableOfContentsPath)) {
vscode.commands.executeCommand('setContext', 'bookOpened', true);
} else {
this._errorMessage = loc.missingTocError;
@@ -111,16 +144,16 @@ export class BookModel {
}
if (this._tableOfContentsPath) {
let root: string = path.dirname(path.dirname(this._tableOfContentsPath));
try {
let fileContents = await fsPromises.readFile(path.join(root, '_config.yml'), 'utf-8');
let fileContents = await fsPromises.readFile(this._configPath, 'utf-8');
const config = yaml.safeLoad(fileContents.toString());
fileContents = await fsPromises.readFile(this._tableOfContentsPath, 'utf-8');
const tableOfContents: any = yaml.safeLoad(fileContents.toString());
let tableOfContents: any = yaml.safeLoad(fileContents.toString());
let book: BookTreeItem = new BookTreeItem({
version: this._bookVersion,
title: config.title,
contentPath: this._tableOfContentsPath,
root: root,
root: this._rootPath,
tableOfContents: { sections: this.parseJupyterSections(tableOfContents) },
page: tableOfContents,
type: BookTreeItemType.Book,
@@ -145,11 +178,11 @@ export class BookModel {
return this._bookItems;
}
public async getSections(tableOfContents: IJupyterBookToc, sections: IJupyterBookSection[], root: string): Promise<BookTreeItem[]> {
public async getSections(tableOfContents: IJupyterBookToc, sections: JupyterBookSection[], root: string, book: BookTreeItemFormat): Promise<BookTreeItem[]> {
let notebooks: BookTreeItem[] = [];
for (let i = 0; i < sections.length; i++) {
if (sections[i].url) {
if (sections[i].external) {
if (sections[i].url || (sections[i] as IJupyterBookSectionV2).file) {
if (sections[i].url && ((sections[i] as IJupyterBookSectionV1).external || book.version === BookVersion.v2)) {
let externalLink: BookTreeItem = new BookTreeItem({
title: sections[i].title,
contentPath: undefined,
@@ -158,7 +191,8 @@ export class BookModel {
page: sections[i],
type: BookTreeItemType.ExternalLink,
treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
isUntitled: this.openAsUntitled
isUntitled: this.openAsUntitled,
version: book.version
},
{
light: this._extensionContext.asAbsolutePath('resources/light/link.svg'),
@@ -168,20 +202,29 @@ export class BookModel {
notebooks.push(externalLink);
} else {
let pathToNotebook = path.join(root, 'content', sections[i].url.concat('.ipynb'));
let pathToMarkdown = path.join(root, 'content', sections[i].url.concat('.md'));
let pathToNotebook: string;
let pathToMarkdown: string;
if (book.version === BookVersion.v2) {
pathToNotebook = path.join(book.root, (sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
pathToMarkdown = path.join(book.root, (sections[i] as IJupyterBookSectionV2).file.concat('.md'));
} else if (sections[i].url) {
pathToNotebook = path.join(book.root, content, (sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
pathToMarkdown = path.join(book.root, content, (sections[i] as IJupyterBookSectionV1).url.concat('.md'));
}
// Note: Currently, if there is an ipynb and a md file with the same name, Jupyter Books only shows the notebook.
// Following Jupyter Books behavior for now
if (await fs.pathExists(pathToNotebook)) {
let notebook = new BookTreeItem({
title: sections[i].title,
title: sections[i].title ? sections[i].title : (sections[i] as IJupyterBookSectionV2).file,
contentPath: pathToNotebook,
root: root,
tableOfContents: tableOfContents,
page: sections[i],
type: BookTreeItemType.Notebook,
treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
isUntitled: this.openAsUntitled
isUntitled: this.openAsUntitled,
version: book.version
},
{
light: this._extensionContext.asAbsolutePath('resources/light/notebook.svg'),
@@ -204,14 +247,15 @@ export class BookModel {
}
} else if (await fs.pathExists(pathToMarkdown)) {
let markdown: BookTreeItem = new BookTreeItem({
title: sections[i].title,
title: sections[i].title ? sections[i].title : (sections[i] as IJupyterBookSectionV2).file,
contentPath: pathToMarkdown,
root: root,
tableOfContents: tableOfContents,
page: sections[i],
type: BookTreeItemType.Markdown,
treeItemCollapsibleState: vscode.TreeItemCollapsibleState.Collapsed,
isUntitled: this.openAsUntitled
isUntitled: this.openAsUntitled,
version: book.version
},
{
light: this._extensionContext.asAbsolutePath('resources/light/markdown.svg'),
@@ -235,7 +279,7 @@ export class BookModel {
* Recursively parses out a section of a Jupyter Book.
* @param section The input data to parse
*/
private parseJupyterSections(section: any[]): IJupyterBookSection[] {
private parseJupyterSections(section: any[]): JupyterBookSection[] {
try {
return section.reduce((acc, val) => Array.isArray(val.sections) ?
acc.concat(val).concat(this.parseJupyterSections(val.sections)) : acc.concat(val), []);
@@ -246,15 +290,25 @@ export class BookModel {
}
throw this._errorMessage;
}
}
public get tableOfContentsPath(): string {
return this._tableOfContentsPath;
}
public get contentFolderPath(): string {
return this._contentFolderPath;
}
public get configPath(): string {
return this._configPath;
}
public get errorMessage(): string {
return this._errorMessage;
}
public get version(): string {
return this._bookVersion;
}
}