ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-17 02:51:36 -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

173
extensions/notebook/resources/notebooks/JupyterBooksCreate.ipynb
View File

@@ -6,7 +6,7 @@
}, },
"language_info": { "language_info": {
"name": "python", "name": "python",
"version": "3.7.2", "version": "3.6.6",
"mimetype": "text/x-python", "mimetype": "text/x-python",
"codemirror_mode": { "codemirror_mode": {
"name": "ipython", "name": "ipython",
@@ -24,8 +24,13 @@
"cell_type": "markdown", "cell_type": "markdown",
"source": [ "source": [
"# Create Jupyter Book\n", "# Create Jupyter Book\n",
"This is a notebook to create a [Jupyter Book](https://jupyterbook.org/intro.html), which is an organized collections of Jupyter notebooks.\n",
"\n", "\n",
"<strong style=\"color: red; opacity: 0.80;\">Note: Jupyter Books in Azure Data Studio only support jupyter-book versions <= 0.6.4 To create a Jupyter Book, we will be uninstalling versions newer than 0.6.4 and replacing with 0.6.4</strong>\n", " \n",
"\n",
"The best way to use this notebook is by clicking Run all in the toolbar above. This will run all the cells in a step-by-step order so that you can create your Jupyter Book.\n",
"\n",
" \n",
"## 1. Installation\n", "## 1. Installation\n",
"\n", "\n",
"To install the Jupyter Book command-line interface (CLI), use `pip`!" "To install the Jupyter Book command-line interface (CLI), use `pip`!"
@@ -39,22 +44,44 @@
"source": [ "source": [
"import sys\r\n", "import sys\r\n",
"\r\n", "\r\n",
"#install jupyter-book 0.6.4\r\n", "def getJupyterBookVersion():\r\n",
"cmd = f'{sys.executable} -m pip show jupyter-book'\r\n", " cmd = f'{sys.executable} -m pip show jupyter-book'\r\n",
"cmdOutput = !{cmd}\r\n", " cmdOutput = !{cmd}\r\n",
"if len(cmdOutput) > 1 and '0.6.4' in cmdOutput[1]:\r\n", " if len(cmdOutput) <= 1:\r\n",
" print('Jupyter-book required version is already installed!')\r\n", " !pip install jupyter-book\r\n",
"elif len(cmdOutput) > 1:\r\n", " cmd = f'{sys.executable} -m pip show jupyter-book'\r\n",
" print('Unsupported version of Jupyter-book installed, Please wait while we uninstall and install the supported version.')\r\n", " cmdOutput = !{cmd}\r\n",
" for x in cmdOutput:\r\n",
" if 'version' in x.lower():\r\n",
" version_str = tuple(x.split(': ')[1].replace('.', ''))\r\n",
" version = tuple(int(x) for x in version_str)\r\n",
" return version, version_str\r\n",
"\r\n",
"try:\r\n",
" version, version_str = getJupyterBookVersion()\r\n",
" if version:\r\n",
" display_version = '.'.join(version_str)\r\n",
" print(f'Jupyter-book version {display_version} is already installed!')\r\n",
" use_current = input(f'Would you like to create a book using the current installed version [{display_version}] of jupyter-book? [y/n]').lower()\r\n",
"\r\n",
" while use_current not in ['yes', 'y', 'no', 'n']:\r\n",
" use_current = input(f'Would you like to create a book using the current installed version [{display_version}] of jupyter-book? [y/n]').lower()\r\n",
" if use_current in ['no', 'n']:\r\n",
" install_version = input(f'Please enter the version you would like to use (eg. 0.7.4)')\r\n",
" if install_version:\r\n",
" !pip uninstall jupyter-book --yes\r\n", " !pip uninstall jupyter-book --yes\r\n",
" !pip install jupyter-book==0.6.4\r\n", " version = ''\r\n",
"else:\r\n",
" print('Installing Jupyter-book...')\r\n", " print('Installing Jupyter-book...')\r\n",
" !pip install jupyter-book==0.6.4" " !pip install jupyter-book==\"$install_version\"\r\n",
" version, _ = getJupyterBookVersion()\r\n",
"except Exception as e:\r\n",
" raise SystemExit(str(e))"
], ],
"metadata": { "metadata": {
"azdata_cell_guid": "8bd77173-2f63-4bf8-95e8-af2a654fc91e", "azdata_cell_guid": "8bd77173-2f63-4bf8-95e8-af2a654fc91e",
"tags": [] "tags": [
"hide_input"
]
}, },
"outputs": [], "outputs": [],
"execution_count": null "execution_count": null
@@ -75,7 +102,11 @@
{ {
"cell_type": "code", "cell_type": "code",
"source": [ "source": [
"import os, re, shutil\r\n", "import os, re, subprocess\r\n",
"from sys import platform\r\n",
"import shutil\r\n",
"\r\n",
"os.environ[\"LC_ALL\"]=\"en_US.UTF-8\"\r\n",
"\r\n", "\r\n",
"try:\r\n", "try:\r\n",
" overwrite = False\r\n", " overwrite = False\r\n",
@@ -91,17 +122,33 @@
"\r\n", "\r\n",
" while (not os.path.exists(content_folder)):\r\n", " while (not os.path.exists(content_folder)):\r\n",
" content_folder = input('Cannot find folder ' + content_folder + '. Please provide another path: ')\r\n", " content_folder = input('Cannot find folder ' + content_folder + '. Please provide another path: ')\r\n",
" \r\n", " if version and version < (0,7,0):\r\n",
" if overwrite:\r\n", " if overwrite:\r\n",
" !jupyter-book create \"$book_name\" --content-folder \"$content_folder\" --overwrite\r\n", " !jupyter-book create \"$book_name\" --content-folder \"$content_folder\" --overwrite\r\n",
" else:\r\n", " else:\r\n",
" !jupyter-book create \"$book_name\" --content-folder \"$content_folder\"\r\n", " !jupyter-book create \"$book_name\" --content-folder \"$content_folder\"\r\n",
" elif version:\r\n",
" if overwrite:\r\n",
" shutil.rmtree(book_name)\r\n",
" else:\r\n",
" # waiting for shutil to remove the directory\r\n",
" while os.path.exists(book_name):\r\n",
" pass\r\n",
" subprocess.check_call(['mkdir', book_name])\r\n",
" content_folder = os.path.join(content_folder,'')\r\n",
" if platform in ['linux', 'darwin']:\r\n",
" subprocess.check_call(['cp', '-r',content_folder, book_name])\r\n",
" else:\r\n",
" subprocess.check_call(['xcopy', content_folder, book_name])\r\n",
" !jupyter-book toc \"$book_name\"\r\n",
"except Exception as e:\r\n", "except Exception as e:\r\n",
" raise SystemExit(str(e))" " raise SystemExit(str(e))"
], ],
"metadata": { "metadata": {
"azdata_cell_guid": "d1a363f0-d854-4466-be87-d01d4c7e51ef", "azdata_cell_guid": "d1a363f0-d854-4466-be87-d01d4c7e51ef",
"tags": [] "tags": [
"hide_input"
]
}, },
"outputs": [], "outputs": [],
"execution_count": null "execution_count": null
@@ -123,22 +170,9 @@
"cell_type": "code", "cell_type": "code",
"source": [ "source": [
"# Update toc file, book title and clean up the directores\n", "# Update toc file, book title and clean up the directores\n",
"\n", "import shutil\n",
"from os import path\n", "from os import path\n",
"tocFilePath = path.join(book_name, \"_data\", \"toc.yml\")\n", "import yaml\n",
"f = open(tocFilePath, \"r\")\n",
"title = ''\n",
"replacedString = ''\n",
"result = f.read()\n",
"f.close()\n",
"contentFolders = []\n",
"\n",
"firstLevelUrls = re.findall(r'^(?:\\s+$[\\r\\n]+)+(\\- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$[\\r\\n]+)', result, re.MULTILINE)\n",
"urls = re.findall(r'- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$', result, re.MULTILINE)\n",
"headers = re.findall(r'- header: [a-zA-Z0-9\\\\.\\s-]+$', result, re.MULTILINE)\n",
"# all the markdown urls are placed at the end of the list. \n",
"possibleMarkdowns = re.findall(r'(- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$[\\r\\n]+)[\\r\\n]', result, re.MULTILINE)\n",
"\n",
"def getMarkdownFile(url):\n", "def getMarkdownFile(url):\n",
" # url are usually defined in toc as: \"- url: <Path\\to\\notebookFile>\"\n", " # url are usually defined in toc as: \"- url: <Path\\to\\notebookFile>\"\n",
" # substring from 7th postion excluding the \"- url: \" from the path\n", " # substring from 7th postion excluding the \"- url: \" from the path\n",
@@ -151,7 +185,38 @@
" markdownFilePath = url[7:].rstrip() + '.md'\n", " markdownFilePath = url[7:].rstrip() + '.md'\n",
" return markdownFilePath\n", " return markdownFilePath\n",
"\n", "\n",
"try:\n", "def getAllSections(visited, data, current):\n",
" if current not in visited:\n",
" visited.append(current)\n",
" for x in range(len(current)):\n",
" if 'sections' in current[x].keys():\n",
" tmp = {}\n",
" tmp['title'] = path.dirname(current[x]['file']).title()\n",
" tmp['file'] = current[x]['file']\n",
" tmp['numbered'] = False\n",
" tmp['expand_sections'] = True\n",
" tmp['sections'] = current[x]['sections']\n",
" current[x] = tmp\n",
" getAllSections(visited, data, current[x]['sections'])\n",
" else:\n",
" current[x]['title'] = path.basename(current[x]['file']).title()\n",
"\n",
"if version < (0,7,0):\n",
" tocFilePath = path.join(book_name, \"_data\", \"toc.yml\")\n",
" f = open(tocFilePath, \"r\")\n",
" title = ''\n",
" replacedString = ''\n",
" result = f.read()\n",
" f.close()\n",
" contentFolders = []\n",
"\n",
" firstLevelUrls = re.findall(r'^(?:\\s+$[\\r\\n]+)+(\\- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$[\\r\\n]+)', result, re.MULTILINE)\n",
" urls = re.findall(r'- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$', result, re.MULTILINE)\n",
" headers = re.findall(r'- header: [a-zA-Z0-9\\\\.\\s-]+$', result, re.MULTILINE)\n",
" # all the markdown urls are placed at the end of the list. \n",
" possibleMarkdowns = re.findall(r'(- url: [a-zA-Z0-9\\\\.\\s\\-\\/]+$[\\r\\n]+)[\\r\\n]', result, re.MULTILINE)\n",
"\n",
" try:\n",
" if (firstLevelUrls or headers or urls):\n", " if (firstLevelUrls or headers or urls):\n",
" if (firstLevelUrls and len(firstLevelUrls) == 1):\n", " if (firstLevelUrls and len(firstLevelUrls) == 1):\n",
" for url in firstLevelUrls:\n", " for url in firstLevelUrls:\n",
@@ -249,8 +314,35 @@
" os.remove(path)\n", " os.remove(path)\n",
" if path.is_dir() and path.name not in ('_data', 'content'):\n", " if path.is_dir() and path.name not in ('_data', 'content'):\n",
" shutil.rmtree(path)\n", " shutil.rmtree(path)\n",
"except Exception as e:\n", " except Exception as e:\n",
" raise SystemExit(str(e))" " raise SystemExit(str(e))\n",
"else:\n",
" tocFilePath = path.join(book_name, \"_toc.yml\")\n",
" configFilePath = path.join(book_name, \"_config.yml\")\n",
" visited = []\n",
" # modify generated toc file\n",
" with open(tocFilePath, 'r') as stream:\n",
" data = yaml.safe_load(stream)\n",
" if not isinstance(data, list):\n",
" new_data = []\n",
" for k in data:\n",
" if k == 'file':\n",
" new_data.append({k : data[k]})\n",
" elif k == 'sections':\n",
" new_data[-1].update({k : data[k]})\n",
" data = new_data\n",
" for k in data:\n",
" if 'sections' in k:\n",
" getAllSections([], data, k['sections'])\n",
"\n",
" with open(tocFilePath, 'w') as outfile:\n",
" yaml.dump(data, outfile, sort_keys=False)\n",
" # create config file\n",
" config = {}\n",
" config['title'] = path.basename(book_name).title()\n",
" with open(configFilePath, 'w') as output:\n",
" yaml.dump(config, output, default_flow_style=False)\n",
""
], ],
"metadata": { "metadata": {
"azdata_cell_guid": "6124730b-f52e-4103-8dbb-e3a62325fb55", "azdata_cell_guid": "6124730b-f52e-4103-8dbb-e3a62325fb55",
@@ -284,7 +376,9 @@
], ],
"metadata": { "metadata": {
"azdata_cell_guid": "33d8e1cb-1eec-41ed-a368-1aeef9af62d4", "azdata_cell_guid": "33d8e1cb-1eec-41ed-a368-1aeef9af62d4",
"tags": [] "tags": [
"hide_input"
]
}, },
"outputs": [], "outputs": [],
"execution_count": null "execution_count": null
@@ -294,9 +388,14 @@
"source": [ "source": [
"<span style=\"color:red\">**Note**: On clicking the above link, we create a temporary toc.yml file for your convenience.</span>\r\n", "<span style=\"color:red\">**Note**: On clicking the above link, we create a temporary toc.yml file for your convenience.</span>\r\n",
"\r\n", "\r\n",
"**For versions < 0.7.0**\r\n",
"\r\n",
" Please update that file inside your book (located at: *YourbookPath*/_data/toc.yml) if you want to further customize your book following \r\n", " Please update that file inside your book (located at: *YourbookPath*/_data/toc.yml) if you want to further customize your book following \r\n",
" instructions at https://jupyterbook.org/guide/01-5_tour.html#Table-of-Contents.\r\n", " instructions at https://legacy.jupyterbook.org/guide/01-5_tour.html#Table-of-Contents.\r\n",
"" "\r\n",
"**For the newer versions**\r\n",
"\r\n",
"Please update the _toc.yml file inside your book (located at: YourbookPath/_toc.yml). And refer to the documentation at https://jupyterbook.org/customize/toc.html for further customization."
], ],
"metadata": { "metadata": {
"azdata_cell_guid": "d193d588-847b-4725-9591-098d0fb24343" "azdata_cell_guid": "d193d588-847b-4725-9591-098d0fb24343"

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

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

38
extensions/notebook/src/book/bookTreeItem.ts
View File

@@ -6,9 +6,12 @@
import * as vscode from 'vscode'; import * as vscode from 'vscode';
import * as path from 'path'; import * as path from 'path';
import * as fs from 'fs'; import * as fs from 'fs';
import { IJupyterBookSection, IJupyterBookToc } from '../contracts/content'; import { JupyterBookSection, IJupyterBookToc, IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';
import * as loc from '../common/localizedConstants'; import * as loc from '../common/localizedConstants';
import { isBookItemPinned } from '../common/utils'; import { isBookItemPinned } from '../common/utils';
import { BookVersion } from './bookModel';
const content = 'content';
export enum BookTreeItemType { export enum BookTreeItemType {
Book = 'Book', Book = 'Book',
@@ -26,13 +29,15 @@ export interface BookTreeItemFormat {
type: BookTreeItemType; type: BookTreeItemType;
treeItemCollapsibleState: number; treeItemCollapsibleState: number;
isUntitled: boolean; isUntitled: boolean;
version?: string;
} }
export class BookTreeItem extends vscode.TreeItem { export class BookTreeItem extends vscode.TreeItem {
private _sections: IJupyterBookSection[]; private _sections: JupyterBookSection[];
private _uri: string | undefined; private _uri: string | undefined;
private _previousUri: string; private _previousUri: string;
private _nextUri: string; private _nextUri: string;
public readonly version: string;
public command: vscode.Command; public command: vscode.Command;
constructor(public book: BookTreeItemFormat, icons: any) { constructor(public book: BookTreeItemFormat, icons: any) {
@@ -41,6 +46,7 @@ export class BookTreeItem extends vscode.TreeItem {
if (book.type === BookTreeItemType.Book) { if (book.type === BookTreeItemType.Book) {
this.collapsibleState = book.treeItemCollapsibleState; this.collapsibleState = book.treeItemCollapsibleState;
this._sections = book.page; this._sections = book.page;
this.version = book.version;
if (book.isUntitled) { if (book.isUntitled) {
this.contextValue = 'providedBook'; this.contextValue = 'providedBook';
} else { } else {
@@ -78,7 +84,7 @@ export class BookTreeItem extends vscode.TreeItem {
vscode.TreeItemCollapsibleState.Collapsed : vscode.TreeItemCollapsibleState.Collapsed :
vscode.TreeItemCollapsibleState.None; vscode.TreeItemCollapsibleState.None;
this._sections = this.book.page.sections || this.book.page.subsections; this._sections = this.book.page.sections || this.book.page.subsections;
this._uri = this.book.page.url; this._uri = this.book.version === BookVersion.v1 ? this.book.page.url : this.book.page.file;
if (this.book.tableOfContents.sections) { if (this.book.tableOfContents.sections) {
let index = (this.book.tableOfContents.sections.indexOf(this.book.page)); let index = (this.book.tableOfContents.sections.indexOf(this.book.page));
@@ -101,15 +107,19 @@ export class BookTreeItem extends vscode.TreeItem {
private setPreviousUri(index: number): void { private setPreviousUri(index: number): void {
let i = --index; let i = --index;
while (i > -1) { while (i > -1) {
if (this.book.tableOfContents.sections[i].url) { let pathToNotebook: string;
if (this.book.version === BookVersion.v2 && (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file) {
// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS) // The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
let pathToNotebook = path.posix.join(this.book.root, 'content', this.book.tableOfContents.sections[i].url.concat('.ipynb')); pathToNotebook = path.posix.join(this.book.root, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
} else if ((this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url) {
pathToNotebook = path.posix.join(this.book.root, content, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
}
// eslint-disable-next-line no-sync // eslint-disable-next-line no-sync
if (fs.existsSync(pathToNotebook)) { if (fs.existsSync(pathToNotebook)) {
this._previousUri = pathToNotebook; this._previousUri = pathToNotebook;
return; return;
} }
}
i--; i--;
} }
} }
@@ -117,15 +127,19 @@ export class BookTreeItem extends vscode.TreeItem {
private setNextUri(index: number): void { private setNextUri(index: number): void {
let i = ++index; let i = ++index;
while (i < this.book.tableOfContents.sections.length) { while (i < this.book.tableOfContents.sections.length) {
if (this.book.tableOfContents.sections[i].url) { let pathToNotebook: string;
if (this.book.version === BookVersion.v2 && (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file) {
// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS) // The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
let pathToNotebook = path.posix.join(this.book.root, 'content', this.book.tableOfContents.sections[i].url.concat('.ipynb')); pathToNotebook = path.posix.join(this.book.root, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV2).file.concat('.ipynb'));
} else if ((this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url) {
pathToNotebook = path.posix.join(this.book.root, content, (this.book.tableOfContents.sections[i] as IJupyterBookSectionV1).url.concat('.ipynb'));
}
// eslint-disable-next-line no-sync // eslint-disable-next-line no-sync
if (fs.existsSync(pathToNotebook)) { if (fs.existsSync(pathToNotebook)) {
this._nextUri = pathToNotebook; this._nextUri = pathToNotebook;
return; return;
} }
}
i++; i++;
} }
} }
@@ -164,14 +178,14 @@ export class BookTreeItem extends vscode.TreeItem {
* Helper method to find a child section with a specified URL * Helper method to find a child section with a specified URL
* @param url The url of the section we're searching for * @param url The url of the section we're searching for
*/ */
public findChildSection(url?: string): IJupyterBookSection | undefined { public findChildSection(url?: string): JupyterBookSection | undefined {
if (!url) { if (!url) {
return undefined; return undefined;
} }
return this.findChildSectionRecur(this, url); return this.findChildSectionRecur(this as JupyterBookSection, url);
} }
private findChildSectionRecur(section: IJupyterBookSection, url: string): IJupyterBookSection | undefined { private findChildSectionRecur(section: JupyterBookSection, url: string): JupyterBookSection | undefined {
if (section.url && section.url === url) { if (section.url && section.url === url) {
return section; return section;
} else if (section.sections) { } else if (section.sections) {

61
extensions/notebook/src/book/bookTreeView.ts
View File

@@ -11,16 +11,17 @@ import * as constants from '../common/constants';
import { IPrompter, IQuestion, confirm } from '../prompts/question'; import { IPrompter, IQuestion, confirm } from '../prompts/question';
import CodeAdapter from '../prompts/adapter'; import CodeAdapter from '../prompts/adapter';
import { BookTreeItem, BookTreeItemType } from './bookTreeItem'; import { BookTreeItem, BookTreeItemType } from './bookTreeItem';
import { BookModel } from './bookModel'; import { BookModel, BookVersion } from './bookModel';
import { Deferred } from '../common/promise'; import { Deferred } from '../common/promise';
import { IBookTrustManager, BookTrustManager } from './bookTrustManager'; import { IBookTrustManager, BookTrustManager } from './bookTrustManager';
import * as loc from '../common/localizedConstants'; import * as loc from '../common/localizedConstants';
import * as glob from 'fast-glob'; import * as glob from 'fast-glob';
import { isNullOrUndefined } from 'util'; import { isNullOrUndefined } from 'util';
import { IJupyterBookSectionV2, IJupyterBookSectionV1 } from '../contracts/content';
import { debounce, getPinnedNotebooks } from '../common/utils'; import { debounce, getPinnedNotebooks } from '../common/utils';
import { IBookPinManager, BookPinManager } from './bookPinManager'; import { IBookPinManager, BookPinManager } from './bookPinManager';
const Content = 'content'; const content = 'content';
interface BookSearchResults { interface BookSearchResults {
notebookPaths: string[]; notebookPaths: string[];
@@ -152,7 +153,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
// add file watcher on toc file. // add file watcher on toc file.
if (!isNotebook) { if (!isNotebook) {
fs.watchFile(path.join(bookPath, '_data', 'toc.yml'), async (curr, prev) => { fs.watchFile(this.currentBook.tableOfContentsPath, async (curr, prev) => {
if (curr.mtime > prev.mtime) { if (curr.mtime > prev.mtime) {
let book = this.books.find(book => book.bookPath === bookPath); let book = this.books.find(book => book.bookPath === bookPath);
if (book) { if (book) {
@@ -206,7 +207,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
} finally { } finally {
// remove watch on toc file. // remove watch on toc file.
if (deletedBook && !deletedBook.isNotebook) { if (deletedBook && !deletedBook.isNotebook) {
fs.unwatchFile(path.join(deletedBook.bookPath, '_data', 'toc.yml')); fs.unwatchFile(deletedBook.tableOfContentsPath);
} }
} }
} }
@@ -247,7 +248,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
const sectionToOpen = bookRoot.findChildSection(urlToOpen); const sectionToOpen = bookRoot.findChildSection(urlToOpen);
urlPath = sectionToOpen?.url; urlPath = sectionToOpen?.url;
} else { } else {
urlPath = this.currentBook.bookItems[0].tableOfContents.sections[0].url; urlPath = this.currentBook.version === BookVersion.v1 ? (this.currentBook.bookItems[0].tableOfContents.sections[0] as IJupyterBookSectionV1).url : (this.currentBook.bookItems[0].tableOfContents.sections[0] as IJupyterBookSectionV2).file;
} }
} }
if (urlPath) { if (urlPath) {
@@ -260,8 +261,8 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
} }
} else { } else {
// The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS) // The Notebook editor expects a posix path for the resource (it will still resolve to the correct fsPath based on OS)
const sectionToOpenMarkdown: string = path.posix.join(this.currentBook.bookPath, Content, urlPath.concat('.md')); const sectionToOpenMarkdown: string = path.posix.join(this.currentBook.contentFolderPath, urlPath.concat('.md'));
const sectionToOpenNotebook: string = path.posix.join(this.currentBook.bookPath, Content, urlPath.concat('.ipynb')); const sectionToOpenNotebook: string = path.posix.join(this.currentBook.contentFolderPath, urlPath.concat('.ipynb'));
if (await fs.pathExists(sectionToOpenMarkdown)) { if (await fs.pathExists(sectionToOpenMarkdown)) {
this.openMarkdown(sectionToOpenMarkdown); this.openMarkdown(sectionToOpenMarkdown);
} }
@@ -411,13 +412,22 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
public async searchJupyterBooks(treeItem?: BookTreeItem): Promise<void> { public async searchJupyterBooks(treeItem?: BookTreeItem): Promise<void> {
let folderToSearch: string; let folderToSearch: string;
if (treeItem && treeItem.sections !== undefined) { if (treeItem && treeItem.sections !== undefined) {
if (treeItem.book.version === BookVersion.v1) {
if (treeItem.uri) { if (treeItem.uri) {
folderToSearch = path.join(treeItem.root, Content, path.dirname(treeItem.uri)); folderToSearch = path.join(treeItem.book.root, content, path.dirname(treeItem.uri));
} else { } else {
folderToSearch = path.join(treeItem.root, Content); folderToSearch = path.join(treeItem.root, content);
} }
} else if (treeItem.book.version === BookVersion.v2) {
if (treeItem.uri) {
folderToSearch = path.join(treeItem.book.root, path.dirname(treeItem.uri));
} else {
folderToSearch = path.join(treeItem.root);
}
}
} else if (this.currentBook && !this.currentBook.isNotebook) { } else if (this.currentBook && !this.currentBook.isNotebook) {
folderToSearch = path.join(this.currentBook.bookPath, Content); folderToSearch = path.join(this.currentBook.contentFolderPath);
} else { } else {
vscode.window.showErrorMessage(loc.noBooksSelectedError); vscode.window.showErrorMessage(loc.noBooksSelectedError);
} }
@@ -476,6 +486,9 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
} }
private async getNotebooksInTree(folderPath: string): Promise<BookSearchResults> { private async getNotebooksInTree(folderPath: string): Promise<BookSearchResults> {
let tocTrimLength: number;
let ignorePaths: string[] = [];
let notebookConfig = vscode.workspace.getConfiguration(constants.notebookConfigKey); let notebookConfig = vscode.workspace.getConfiguration(constants.notebookConfigKey);
let maxDepth = notebookConfig[constants.maxBookSearchDepth]; let maxDepth = notebookConfig[constants.maxBookSearchDepth];
// Use default value if user enters an invalid value // Use default value if user enters an invalid value
@@ -486,13 +499,26 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
} }
let escapedPath = glob.escapePath(folderPath.replace(/\\/g, '/')); let escapedPath = glob.escapePath(folderPath.replace(/\\/g, '/'));
let bookFilter = path.posix.join(escapedPath, '**', '_data', 'toc.yml'); let bookV1Filter = path.posix.join(escapedPath, '**', '_data', 'toc.yml');
let bookPaths = await glob(bookFilter, { deep: maxDepth }); let bookV2Filter = path.posix.join(escapedPath, '**', '_toc.yml');
let tocTrimLength = '/_data/toc.yml'.length * -1; let bookPaths = await glob([bookV1Filter, bookV2Filter], { deep: maxDepth });
bookPaths = bookPaths.map(path => path.slice(0, tocTrimLength)); let ignoreNotebook: string[];
bookPaths = bookPaths.map(function (path) {
if (path.includes('/_data/toc.yml')) {
tocTrimLength = '/_data/toc.yml'.length * -1;
ignoreNotebook = ['/**/*.ipynb'];
} else {
tocTrimLength = '/_toc.yml'.length * -1;
ignoreNotebook = ['/**/*.ipynb', '/*.ipynb'];
}
path = path.slice(0, tocTrimLength);
ignoreNotebook.map(notebook => ignorePaths.push(glob.escapePath(path) + notebook));
return path;
});
let notebookFilter = path.posix.join(escapedPath, '**', '*.ipynb'); let notebookFilter = path.posix.join(escapedPath, '**', '*.ipynb');
let notebookPaths = await glob(notebookFilter, { ignore: bookPaths.map(path => glob.escapePath(path) + '/**/*.ipynb'), deep: maxDepth });
let notebookPaths = await glob(notebookFilter, { ignore: ignorePaths, deep: maxDepth });
return { notebookPaths: notebookPaths, bookPaths: bookPaths }; return { notebookPaths: notebookPaths, bookPaths: bookPaths };
} }
@@ -512,7 +538,7 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
getChildren(element?: BookTreeItem): Thenable<BookTreeItem[]> { getChildren(element?: BookTreeItem): Thenable<BookTreeItem[]> {
if (element) { if (element) {
if (element.sections) { if (element.sections) {
return Promise.resolve(this.currentBook.getSections(element.tableOfContents, element.sections, element.root).then(sections => { return sections; })); return Promise.resolve(this.currentBook.getSections(element.tableOfContents, element.sections, element.root, element.book).then(sections => { return sections; }));
} else { } else {
return Promise.resolve([]); return Promise.resolve([]);
} }
@@ -528,7 +554,8 @@ export class BookTreeViewProvider implements vscode.TreeDataProvider<BookTreeIte
getParent(element?: BookTreeItem): vscode.ProviderResult<BookTreeItem> { getParent(element?: BookTreeItem): vscode.ProviderResult<BookTreeItem> {
if (element?.uri) { if (element?.uri) {
let parentPath: string; let parentPath: string;
parentPath = path.join(element.root, Content, element.uri.substring(0, element.uri.lastIndexOf(path.posix.sep))); let contentFolder = element.book.version === BookVersion.v1 ? path.join(element.book.root, content) : element.book.root;
parentPath = path.join(contentFolder, element.uri.substring(0, element.uri.lastIndexOf(path.posix.sep)));
if (parentPath === element.root) { if (parentPath === element.root) {
return undefined; return undefined;
} }

43
extensions/notebook/src/contracts/content.ts
View File

@@ -64,7 +64,7 @@ export type OutputType =
| 'update_display_data'; | 'update_display_data';
export interface IJupyterBookToc { export interface IJupyterBookToc {
sections: IJupyterBookSection[]; sections: JupyterBookSection[];
} }
/** /**
@@ -73,7 +73,7 @@ export interface IJupyterBookToc {
* This is taken from https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/book_template/_data/toc.yml but is not * This is taken from https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/book_template/_data/toc.yml but is not
* enforced so invalid JSON may result in expected values being undefined. * enforced so invalid JSON may result in expected values being undefined.
*/ */
export interface IJupyterBookSection { export interface IJupyterBookSectionV1 {
/** /**
* Title of chapter or section * Title of chapter or section
*/ */
@@ -85,7 +85,7 @@ export interface IJupyterBookSection {
/** /**
* Contains a list of more entries that make up the chapter's/section's sub-sections * Contains a list of more entries that make up the chapter's/section's sub-sections
*/ */
sections?: IJupyterBookSection[]; sections?: IJupyterBookSectionV1[];
/** /**
* If the section shouldn't have a number in the sidebar * If the section shouldn't have a number in the sidebar
*/ */
@@ -114,3 +114,40 @@ export interface IJupyterBookSection {
*/ */
header?: boolean; header?: boolean;
} }
/**
* A section of a Jupyter book.
*
* This is taken from https://github.com/jupyter/jupyter-book/blob/master/jupyter_book/book_template/_toc.yml but is not
* enforced so invalid JSON may result in expected values being undefined.
*/
export interface IJupyterBookSectionV2 {
/**
* Title of chapter or section
*/
title?: string;
/**
* Path to notebook relative to root folder.
*/
file?: string;
/**
* Contains a list of more entries that make up the chapter's/section's sub-sections
*/
sections?: IJupyterBookSectionV2[];
/**
* If the section shouldn't have a number in the sidebar
*/
numbered?: boolean;
/**
* If you'd like the sections of this chapter to always be expanded in the sidebar.
*/
expand_sections?: boolean;
/**
* External link
*/
url?: string;
}
// type that supports new and old version
export type JupyterBookSection = IJupyterBookSectionV1 | IJupyterBookSectionV2;

390
extensions/notebook/src/test/book/book.test.ts
View File

@@ -47,7 +47,6 @@ export function equalBookItems(book: BookTreeItem, expectedBook: IExpectedBookIt
describe('BooksTreeViewTests', function () { describe('BooksTreeViewTests', function () {
describe('BookTreeViewProvider', () => { describe('BookTreeViewProvider', () => {
let mockExtensionContext: vscode.ExtensionContext; let mockExtensionContext: vscode.ExtensionContext;
let appContext: AppContext; let appContext: AppContext;
let nonBookFolderPath: string; let nonBookFolderPath: string;
@@ -418,21 +417,54 @@ describe('BooksTreeViewTests', function () {
}); });
describe('BookTreeViewProvider.getTableOfContentFiles', function (): void { describe('BookTreeViewProvider.getTableOfContentFiles', function() {
let rootFolderPath: string; let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let tableOfContentsFile: string;
let bookTreeViewProvider: BookTreeViewProvider; let bookTreeViewProvider: BookTreeViewProvider;
let runs = [
{
it: 'v1',
folderPaths : {
'dataFolderPath' : path.join(rootFolderPath, '_data'),
'contentFolderPath' : path.join(rootFolderPath, 'content'),
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableOfContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
'tableOfContentsFileIgnore' : path.join(rootFolderPath, 'toc.yml')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n url: /notebook1\n sections:\n - title: Notebook2\n url: /notebook2\n - title: Notebook3\n url: /notebook3\n- title: Markdown\n url: /markdown\n- title: GitHub\n url: https://github.com/\n external: true'
}
},
{
it: 'v2',
folderPaths : {
'dataFolderPath' : path.join(rootFolderPath, '_data'),
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableOfContentsFile' : path.join(rootFolderPath, '_toc.yml'),
'notebook2File' : path.join(rootFolderPath,'notebook2.ipynb'),
'tableOfContentsFileIgnore' : path.join(rootFolderPath, '_data', 'toc.yml')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n file: /notebook1\n sections:\n - title: Notebook2\n file: /notebook2\n - title: Notebook3\n file: /notebook3\n- title: Markdown\n file: /markdown\n- title: GitHub\n url: https://github.com/\n'
}
}
];
runs.forEach(function (run){
describe('BookTreeViewProvider.getTableOfContentFiles on ' + run.it, function (): void {
let folder: vscode.WorkspaceFolder; let folder: vscode.WorkspaceFolder;
this.beforeAll(async () => { before(async () => {
rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let dataFolderPath: string = path.join(rootFolderPath, '_data');
tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
let tableOfContentsFileIgnore: string = path.join(rootFolderPath, 'toc.yml');
await fs.mkdir(rootFolderPath); await fs.mkdir(rootFolderPath);
await fs.mkdir(dataFolderPath); await fs.mkdir(run.folderPaths.dataFolderPath);
await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n url: /notebook1\n sections:\n - title: Notebook2\n url: /notebook2\n - title: Notebook3\n url: /notebook3\n- title: Markdown\n url: /markdown\n- title: GitHub\n url: https://github.com/\n external: true'); if(run.it === 'v1') {
await fs.writeFile(tableOfContentsFileIgnore, ''); await fs.mkdir(run.folderPaths.contentFolderPath);
}
await fs.writeFile(run.folderPaths.tableOfContentsFile, run.contents.toc);
await fs.writeFile(run.folderPaths.tableOfContentsFileIgnore, '');
await fs.writeFile(run.folderPaths.notebook2File, '');
const mockExtensionContext = new MockExtensionContext(); const mockExtensionContext = new MockExtensionContext();
folder = { folder = {
uri: vscode.Uri.file(rootFolderPath), uri: vscode.Uri.file(rootFolderPath),
@@ -444,35 +476,71 @@ describe('BooksTreeViewTests', function () {
await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]); await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
}); });
if(run.it === 'v1') {
it('should ignore toc.yml files not in _data folder', async () => { it('should ignore toc.yml files not in _data folder', async () => {
await bookTreeViewProvider.currentBook.loadTableOfContentFiles(rootFolderPath); await bookTreeViewProvider.currentBook.readBookStructure(rootFolderPath);
await bookTreeViewProvider.currentBook.loadTableOfContentFiles();
let path = bookTreeViewProvider.currentBook.tableOfContentsPath; let path = bookTreeViewProvider.currentBook.tableOfContentsPath;
should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(tableOfContentsFile).fsPath); should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(run.folderPaths.tableOfContentsFile).fsPath);
}); });
} else if (run.it === 'v2'){
it('should ignore toc.yml files not under the root book folder', async () => {
await bookTreeViewProvider.currentBook.readBookStructure(rootFolderPath);
await bookTreeViewProvider.currentBook.loadTableOfContentFiles();
let path = bookTreeViewProvider.currentBook.tableOfContentsPath;
should(vscode.Uri.file(path).fsPath).equal(vscode.Uri.file(run.folderPaths.tableOfContentsFile).fsPath);
});
}
this.afterAll(async function (): Promise<void> { after(async function (): Promise<void> {
if (await exists(rootFolderPath)) { if (await exists(rootFolderPath)) {
await promisify(rimraf)(rootFolderPath); await promisify(rimraf)(rootFolderPath);
} }
}); });
}); });
});
});
describe('BookTreeViewProvider.getBooks', function() {
describe('BookTreeViewProvider.getBooks', function (): void { let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let rootFolderPath: string;
let configFile: string;
let folder: vscode.WorkspaceFolder;
let bookTreeViewProvider: BookTreeViewProvider; let bookTreeViewProvider: BookTreeViewProvider;
let tocFile: string; let runs = [
{
this.beforeAll(async () => { it: 'v1',
rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`); folderPaths : {
let dataFolderPath: string = path.join(rootFolderPath, '_data'); 'dataFolderPath' : path.join(rootFolderPath, '_data'),
configFile = path.join(rootFolderPath, '_config.yml'); 'contentFolderPath' : path.join(rootFolderPath, 'content'),
tocFile = path.join(dataFolderPath, 'toc.yml'); 'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n url: /notebook1\n- title: Notebook2\n url: /notebook2'
}
}, {
it: 'v2',
folderPaths : {
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableofContentsFile' : path.join(rootFolderPath, '_toc.yml'),
'notebook2File' : path.join(rootFolderPath, 'notebook2.ipynb'),
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n file: /notebook1\n- title: Notebook2\n file: /notebook2'
}
}
];
runs.forEach(function (run){
describe('BookTreeViewProvider.getBooks on ' + run.it, function (): void {
let folder: vscode.WorkspaceFolder;
before(async () => {
await fs.mkdir(rootFolderPath); await fs.mkdir(rootFolderPath);
await fs.mkdir(dataFolderPath); if(run.it === 'v1'){
await fs.writeFile(tocFile, 'title: Test'); await fs.mkdir(run.folderPaths.dataFolderPath);
await fs.mkdir(run.folderPaths.contentFolderPath);
}
await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.config);
const mockExtensionContext = new MockExtensionContext(); const mockExtensionContext = new MockExtensionContext();
folder = { folder = {
uri: vscode.Uri.file(rootFolderPath), uri: vscode.Uri.file(rootFolderPath),
@@ -486,37 +554,59 @@ describe('BooksTreeViewTests', function () {
it('should show error message if config.yml file not found', async () => { it('should show error message if config.yml file not found', async () => {
await bookTreeViewProvider.currentBook.readBooks(); await bookTreeViewProvider.currentBook.readBooks();
should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `ENOENT: no such file or directory, open '${configFile}'`)); should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `ENOENT: no such file or directory, open '${run.folderPaths.configFile}'`));
}); });
it('should show error if toc.yml file format is invalid', async function (): Promise<void> { it('should show error if toc.yml file format is invalid', async function (): Promise<void> {
await fs.writeFile(configFile, 'title: Test Book'); await fs.writeFile(run.folderPaths.configFile, run.contents.config);
await bookTreeViewProvider.currentBook.readBooks(); await bookTreeViewProvider.currentBook.readBooks();
should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `Invalid toc file`)); should(bookTreeViewProvider.currentBook.errorMessage).equal(readBookError(bookTreeViewProvider.currentBook.bookPath, `Invalid toc file`));
}); });
this.afterAll(async function (): Promise<void> { after(async function (): Promise<void> {
if (await exists(rootFolderPath)) { if (await exists(rootFolderPath)) {
await promisify(rimraf)(rootFolderPath); await promisify(rimraf)(rootFolderPath);
} }
}); });
}); });
})});
describe('BookTreeViewProvider.getSections', function() {
describe('BookTreeViewProvider.getSections', function (): void { let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let rootFolderPath: string;
let tableOfContentsFile: string;
let bookTreeViewProvider: BookTreeViewProvider; let bookTreeViewProvider: BookTreeViewProvider;
let folder: vscode.WorkspaceFolder; let runs = [
{
it: 'v1',
folderPaths : {
'dataFolderPath' : path.join(rootFolderPath, '_data'),
'contentFolderPath' : path.join(rootFolderPath, 'content'),
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n url: /notebook1\n- title: Notebook2\n url: /notebook2'
}
},{
it: 'v2',
folderPaths : {
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableofContentsFile' : path.join(rootFolderPath,'_toc.yml'),
'notebook2File' : path.join(rootFolderPath,'notebook2.ipynb'),
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n file: /notebook1\n- title: Notebook2\n file: /notebook2'
}
}
];
runs.forEach(function (run){
describe('BookTreeViewProvider.getSections on ' + run.it, function (): void {
let folder: vscode.WorkspaceFolder[];
let expectedNotebook2: IExpectedBookItem; let expectedNotebook2: IExpectedBookItem;
this.beforeAll(async () => { before(async () => {
rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let dataFolderPath = path.join(rootFolderPath, '_data');
let contentFolderPath = path.join(rootFolderPath, 'content');
let configFile = path.join(rootFolderPath, '_config.yml');
tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
let notebook2File = path.join(contentFolderPath, 'notebook2.ipynb');
expectedNotebook2 = { expectedNotebook2 = {
title: 'Notebook2', title: 'Notebook2',
url: '/notebook2', url: '/notebook2',
@@ -524,60 +614,87 @@ describe('BooksTreeViewTests', function () {
nextUri: undefined nextUri: undefined
}; };
await fs.mkdir(rootFolderPath); await fs.mkdir(rootFolderPath);
await fs.mkdir(dataFolderPath); if(run.it === 'v1'){
await fs.mkdir(contentFolderPath); await fs.mkdir(run.folderPaths.dataFolderPath);
await fs.writeFile(configFile, 'title: Test Book'); await fs.mkdir(run.folderPaths.contentFolderPath);
await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n url: /notebook1\n- title: Notebook2\n url: /notebook2'); }
await fs.writeFile(notebook2File, ''); await fs.writeFile(run.folderPaths.configFile, run.contents.config);
await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.toc);
await fs.writeFile(run.folderPaths.notebook2File, '');
const mockExtensionContext = new MockExtensionContext(); const mockExtensionContext = new MockExtensionContext();
folder = { folder = [{
uri: vscode.Uri.file(rootFolderPath), uri: vscode.Uri.file(rootFolderPath),
name: '', name: '',
index: 0 index: 0
}; }];
bookTreeViewProvider = new BookTreeViewProvider([folder], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator); bookTreeViewProvider = new BookTreeViewProvider(folder, mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000)); let errorCase = new Promise((resolve, reject) => setTimeout(() => resolve(), 5000));
await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]); await Promise.race([bookTreeViewProvider.initialized, errorCase.then(() => { throw new Error('BookTreeViewProvider did not initialize in time'); })]);
}); });
it('should show error if notebook or markdown file is missing', async function (): Promise<void> { it('should show error if notebook or markdown file is missing', async function (): Promise<void> {
let books: BookTreeItem[] = bookTreeViewProvider.currentBook.bookItems; let books: BookTreeItem[] = bookTreeViewProvider.currentBook.bookItems;
let children = await bookTreeViewProvider.currentBook.getSections({ sections: [] }, books[0].sections, rootFolderPath); let children = await bookTreeViewProvider.currentBook.getSections({ sections: [] }, books[0].sections, rootFolderPath, books[0].book);
should(bookTreeViewProvider.currentBook.errorMessage).equal('Missing file : Notebook1'); should(bookTreeViewProvider.currentBook.errorMessage).equal('Missing file : Notebook1');
// rest of book should be detected correctly even with a missing file // rest of book should be detected correctly even with a missing file
equalBookItems(children[0], expectedNotebook2); equalBookItems(children[0], expectedNotebook2);
}); });
this.afterAll(async function (): Promise<void> { after(async function (): Promise<void> {
if (await exists(rootFolderPath)) { if (await exists(rootFolderPath)) await promisify(rimraf)(rootFolderPath);
await promisify(rimraf)(rootFolderPath);
}
}); });
}); });
})});
describe('BookTreeViewProvider.Commands', function (): void { describe('BookTreeViewProvider.Commands', function() {
let rootFolderPath: string; let rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`);
let tableOfContentsFile: string;
let bookTreeViewProvider: BookTreeViewProvider; let bookTreeViewProvider: BookTreeViewProvider;
let runs = [
this.beforeAll(async () => { {
rootFolderPath = path.join(os.tmpdir(), `BookTestData_${uuid.v4()}`); it: 'v1',
let dataFolderPath = path.join(rootFolderPath, '_data'); folderPaths : {
let contentFolderPath = path.join(rootFolderPath, 'content'); 'dataFolderPath' : path.join(rootFolderPath, '_data'),
let configFile = path.join(rootFolderPath, '_config.yml'); 'contentFolderPath' : path.join(rootFolderPath, 'content'),
tableOfContentsFile = path.join(dataFolderPath, 'toc.yml'); 'configFile' : path.join(rootFolderPath, '_config.yml'),
let notebook1File = path.join(contentFolderPath, 'notebook1.ipynb'); 'tableofContentsFile' : path.join(rootFolderPath,'_data', 'toc.yml'),
let notebook2File = path.join(contentFolderPath, 'notebook2.ipynb'); 'notebook1File' : path.join(rootFolderPath, 'content', 'notebook1.ipynb'),
let markdownFile = path.join(contentFolderPath, 'readme.md'); 'notebook2File' : path.join(rootFolderPath, 'content', 'notebook2.ipynb'),
'markdownFile' : path.join(rootFolderPath, 'content', 'readme.md')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Home\n url: /readme\n- title: Notebook1\n url: /notebook1\n- title: Notebook2\n url: /notebook2'
}
},
{
it: 'v2',
folderPaths : {
'configFile' : path.join(rootFolderPath, '_config.yml'),
'tableofContentsFile' : path.join(rootFolderPath, '_toc.yml'),
'notebook1File' : path.join(rootFolderPath, 'notebook1.ipynb'),
'notebook2File' : path.join(rootFolderPath, 'notebook2.ipynb'),
'markdownFile' : path.join(rootFolderPath, 'readme.md')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Home\n file: /readme\n- title: Notebook1\n file: /notebook1\n- title: Notebook2\n file: /notebook2'
}
}
];
runs.forEach(function (run){
describe('BookTreeViewProvider.Commands on ' + run.it, function (): void {
before(async () => {
await fs.mkdir(rootFolderPath); await fs.mkdir(rootFolderPath);
await fs.mkdir(dataFolderPath); if(run.it === 'v1'){
await fs.mkdir(contentFolderPath); await fs.mkdir(run.folderPaths.dataFolderPath);
await fs.writeFile(configFile, 'title: Test Book'); await fs.mkdir(run.folderPaths.contentFolderPath);
await fs.writeFile(tableOfContentsFile, '- title: Home\n url: /readme\n- title: Notebook1\n url: /notebook1\n- title: Notebook2\n url: /notebook2'); }
await fs.writeFile(notebook1File, ''); await fs.writeFile(run.folderPaths.configFile, run.contents.config);
await fs.writeFile(notebook2File, ''); await fs.writeFile(run.folderPaths.tableofContentsFile, run.contents.toc);
await fs.writeFile(markdownFile, ''); await fs.writeFile(run.folderPaths.notebook1File, '');
await fs.writeFile(run.folderPaths.notebook2File, '');
await fs.writeFile(run.folderPaths.markdownFile, '');
const mockExtensionContext = new MockExtensionContext(); const mockExtensionContext = new MockExtensionContext();
bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator); bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
@@ -602,7 +719,7 @@ describe('BooksTreeViewTests', function () {
it('openMarkdown should open markdown in the editor', async () => { it('openMarkdown should open markdown in the editor', async () => {
let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand'); let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
let notebookPath = path.join(rootFolderPath, 'content', 'readme.md'); let notebookPath = run.folderPaths.markdownFile;
bookTreeViewProvider.openMarkdown(notebookPath); bookTreeViewProvider.openMarkdown(notebookPath);
should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview'); should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
}); });
@@ -610,20 +727,20 @@ describe('BooksTreeViewTests', function () {
// TODO: Need to investigate why it's failing on linux. // TODO: Need to investigate why it's failing on linux.
it.skip('openNotebook should open notebook in the editor', async () => { it.skip('openNotebook should open notebook in the editor', async () => {
let showNotebookSpy = sinon.spy(azdata.nb, 'showNotebookDocument'); let showNotebookSpy = sinon.spy(azdata.nb, 'showNotebookDocument');
let notebookPath = path.join(rootFolderPath, 'content', 'notebook2.ipynb'); let notebookPath = run.folderPaths.notebook2File;
await bookTreeViewProvider.openNotebook(notebookPath); await bookTreeViewProvider.openNotebook(notebookPath);
should(showNotebookSpy.calledWith(vscode.Uri.file(notebookPath))).be.true(`Should have opened the notebook from ${notebookPath} in the editor.`); should(showNotebookSpy.calledWith(vscode.Uri.file(notebookPath))).be.true(`Should have opened the notebook from ${notebookPath} in the editor.`);
}); });
it('openNotebookAsUntitled should open a notebook as untitled file in the editor', async () => { it('openNotebookAsUntitled should open a notebook as untitled file in the editor', async () => {
let notebookPath = path.join(rootFolderPath, 'content', 'notebook2.ipynb'); let notebookPath = run.folderPaths.notebook2File;
await bookTreeViewProvider.openNotebookAsUntitled(notebookPath); await bookTreeViewProvider.openNotebookAsUntitled(notebookPath);
should(azdata.nb.notebookDocuments.find(doc => doc.uri.scheme === 'untitled')).not.be.undefined(); should(azdata.nb.notebookDocuments.find(doc => doc.uri.scheme === 'untitled')).not.be.undefined();
}); });
it('openExternalLink should open link', async () => { it('openExternalLink should open link', async () => {
let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand'); let executeCommandSpy = sinon.spy(vscode.commands, 'executeCommand');
let notebookPath = path.join(rootFolderPath, 'content', 'readme.md'); let notebookPath = run.folderPaths.markdownFile;
bookTreeViewProvider.openMarkdown(notebookPath); bookTreeViewProvider.openMarkdown(notebookPath);
should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview'); should(executeCommandSpy.calledWith('markdown.showPreview')).be.true('openMarkdown should have called markdown.showPreview');
}); });
@@ -658,7 +775,7 @@ describe('BooksTreeViewTests', function () {
}); });
it('should get notebook path with untitled schema on openNotebookAsUntitled', async () => { it('should get notebook path with untitled schema on openNotebookAsUntitled', async () => {
let notebookUri = bookTreeViewProvider.getUntitledNotebookUri(path.join(rootFolderPath, 'content', 'notebook2.ipynb')); let notebookUri = bookTreeViewProvider.getUntitledNotebookUri(run.folderPaths.notebook2File);
should(notebookUri.scheme).equal('untitled', 'Failed to get untitled uri of the resource'); should(notebookUri.scheme).equal('untitled', 'Failed to get untitled uri of the resource');
}); });
@@ -710,44 +827,70 @@ describe('BooksTreeViewTests', function () {
should(bookTreeViewProvider.books.length).equal(length - 1, 'Failed to remove the book on close'); should(bookTreeViewProvider.books.length).equal(length - 1, 'Failed to remove the book on close');
}); });
this.afterAll(async function (): Promise<void> { after(async function (): Promise<void> {
if (await exists(rootFolderPath)) { if (await exists(rootFolderPath)) {
await promisify(rimraf)(rootFolderPath); await promisify(rimraf)(rootFolderPath);
} }
}); });
}); });
});
});
describe('BookTreeViewProvider.openNotebookFolder', function (): void { describe('BookTreeViewProvider.openNotebookFolder', function() {
let rootFolderPath: string; let rootFolderPath = path.join(os.tmpdir(), `BookFolderTest_${uuid.v4()}`);
let bookFolderPath: string;
let bookTitle: string;
let notebookFolderPath: string;
let tableOfContentsFile: string;
let standaloneNotebookTitle: string;
let standaloneNotebookFile: string;
let bookTreeViewProvider: BookTreeViewProvider; let bookTreeViewProvider: BookTreeViewProvider;
let runs = [
{
it: 'v1',
folderPaths : {
'bookFolderPath' : path.join(rootFolderPath, 'BookTestData'),
'dataFolderPath' : path.join(rootFolderPath, 'BookTestData', '_data'),
'contentFolderPath' : path.join(rootFolderPath, 'BookTestData', 'content'),
'configFile' : path.join(rootFolderPath, 'BookTestData', '_config.yml'),
'tableOfContentsFile' : path.join(rootFolderPath,'BookTestData','_data', 'toc.yml'),
'bookNotebookFile' : path.join(rootFolderPath, 'BookTestData', 'content', 'notebook1.ipynb'),
'notebookFolderPath' : path.join(rootFolderPath, 'NotebookTestData'),
'standaloneNotebookFile' : path.join(rootFolderPath, 'NotebookTestData','notebook2.ipynb')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n url: /notebook1',
'bookTitle' : 'Test Book',
'standaloneNotebookTitle' : 'notebook2'
}
},
{
it: 'v2',
folderPaths : {
'bookFolderPath' : path.join(rootFolderPath, 'BookTestData'),
'configFile' : path.join(rootFolderPath, 'BookTestData', '_config.yml'),
'tableOfContentsFile' : path.join(rootFolderPath,'BookTestData', '_toc.yml'),
'bookNotebookFile' : path.join(rootFolderPath, 'BookTestData','notebook1.ipynb'),
'notebookFolderPath' : path.join(rootFolderPath, 'NotebookTestData'),
'standaloneNotebookFile' : path.join(rootFolderPath, 'NotebookTestData','notebook2.ipynb')
},
contents : {
'config' : 'title: Test Book',
'toc' : '- title: Notebook1\n file: /notebook1',
'bookTitle' : 'Test Book',
'standaloneNotebookTitle' : 'notebook2'
}
}];
runs.forEach(function (run){
describe('BookTreeViewProvider.openNotebookFolder on ' + run.it, function (): void {
before(async () => {
this.beforeAll(async () => {
rootFolderPath = path.join(os.tmpdir(), `BookFolderTest_${uuid.v4()}`);
bookFolderPath = path.join(rootFolderPath, 'BookTestData');
let dataFolderPath = path.join(bookFolderPath, '_data');
let contentFolderPath = path.join(bookFolderPath, 'content');
let configFile = path.join(bookFolderPath, '_config.yml');
tableOfContentsFile = path.join(dataFolderPath, 'toc.yml');
let bookNotebookFile = path.join(contentFolderPath, 'notebook1.ipynb');
notebookFolderPath = path.join(rootFolderPath, 'NotebookTestData');
standaloneNotebookTitle = 'notebook2';
standaloneNotebookFile = path.join(notebookFolderPath, `${standaloneNotebookTitle}.ipynb`);
await fs.mkdir(rootFolderPath); await fs.mkdir(rootFolderPath);
await fs.mkdir(bookFolderPath); await fs.mkdir(run.folderPaths.bookFolderPath);
await fs.mkdir(dataFolderPath); if(run.it === 'v1') {
await fs.mkdir(contentFolderPath); await fs.mkdir(run.folderPaths.dataFolderPath);
await fs.mkdir(notebookFolderPath); await fs.mkdir(run.folderPaths.contentFolderPath);
bookTitle = 'Test Book'; }
await fs.writeFile(configFile, `title: ${bookTitle}`); await fs.mkdir(run.folderPaths.notebookFolderPath);
await fs.writeFile(tableOfContentsFile, '- title: Notebook1\n url: /notebook1'); await fs.writeFile(run.folderPaths.configFile, run.contents.config);
await fs.writeFile(bookNotebookFile, ''); await fs.writeFile(run.folderPaths.tableOfContentsFile, run.contents.toc);
await fs.writeFile(standaloneNotebookFile, ''); await fs.writeFile(run.folderPaths.bookNotebookFile, '');
await fs.writeFile(run.folderPaths.standaloneNotebookFile, '');
const mockExtensionContext = new MockExtensionContext(); const mockExtensionContext = new MockExtensionContext();
bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator); bookTreeViewProvider = new BookTreeViewProvider([], mockExtensionContext, false, 'bookTreeView', NavigationProviders.NotebooksNavigator);
@@ -764,25 +907,25 @@ describe('BooksTreeViewTests', function () {
}); });
it('should include only books when opening books folder', async () => { it('should include only books when opening books folder', async () => {
await bookTreeViewProvider.loadNotebooksInFolder(bookFolderPath); await bookTreeViewProvider.loadNotebooksInFolder(run.folderPaths.bookFolderPath);
should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one book'); should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one book');
validateIsBook(bookTreeViewProvider.books[0]); validateIsBook(bookTreeViewProvider.books[0]);
}); });
it('should include only notebooks when opening notebooks folder', async () => { it('should include only notebooks when opening notebooks folder', async () => {
await bookTreeViewProvider.loadNotebooksInFolder(notebookFolderPath); await bookTreeViewProvider.loadNotebooksInFolder(run.folderPaths.notebookFolderPath);
should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one notebook'); should(bookTreeViewProvider.books.length).equal(1, 'Should have loaded only one notebook');
validateIsNotebook(bookTreeViewProvider.books[0]); validateIsNotebook(bookTreeViewProvider.books[0]);
}); });
this.afterEach(async function (): Promise<void> { afterEach(async function (): Promise<void> {
let bookItems = await bookTreeViewProvider.getChildren(); let bookItems = await bookTreeViewProvider.getChildren();
await Promise.all(bookItems.map(bookItem => bookTreeViewProvider.closeBook(bookItem))); await Promise.all(bookItems.map(bookItem => bookTreeViewProvider.closeBook(bookItem)));
}); });
this.afterAll(async function (): Promise<void> { after(async function (): Promise<void> {
if (await exists(rootFolderPath)) { if (await exists(rootFolderPath)) {
await promisify(rimraf)(rootFolderPath); await promisify(rimraf)(rootFolderPath);
} }
@@ -796,9 +939,9 @@ describe('BooksTreeViewTests', function () {
let bookDetails = bookItem.book; let bookDetails = bookItem.book;
should(bookDetails.type).equal(BookTreeItemType.Book); should(bookDetails.type).equal(BookTreeItemType.Book);
should(bookDetails.title).equal(bookTitle); should(bookDetails.title).equal(run.contents.bookTitle);
should(bookDetails.contentPath).equal(tableOfContentsFile.replace(/\\/g, '/')); should(bookDetails.contentPath).equal(run.folderPaths.tableOfContentsFile.replace(/\\/g, '/'));
should(bookDetails.root).equal(bookFolderPath.replace(/\\/g, '/')); should(bookDetails.root).equal(run.folderPaths.bookFolderPath.replace(/\\/g, '/'));
should(bookDetails.tableOfContents.sections).not.equal(undefined); should(bookDetails.tableOfContents.sections).not.equal(undefined);
should(bookDetails.page).not.equal(undefined); should(bookDetails.page).not.equal(undefined);
}; };
@@ -808,15 +951,18 @@ describe('BooksTreeViewTests', function () {
should(book.bookItems.length).equal(1); should(book.bookItems.length).equal(1);
let bookItem = book.bookItems[0]; let bookItem = book.bookItems[0];
should(book.getAllNotebooks().get(vscode.Uri.file(standaloneNotebookFile).fsPath)).equal(bookItem); should(book.getAllNotebooks().get(vscode.Uri.file(run.folderPaths.standaloneNotebookFile).fsPath)).equal(bookItem);
let bookDetails = bookItem.book; let bookDetails = bookItem.book;
should(bookDetails.type).equal(BookTreeItemType.Notebook); should(bookDetails.type).equal(BookTreeItemType.Notebook);
should(bookDetails.title).equal(standaloneNotebookTitle); should(bookDetails.title).equal(run.contents.standaloneNotebookTitle);
should(bookDetails.contentPath).equal(standaloneNotebookFile.replace(/\\/g, '/')); should(bookDetails.contentPath).equal(run.folderPaths.standaloneNotebookFile.replace(/\\/g, '/'));
should(bookDetails.root).equal(notebookFolderPath.replace(/\\/g, '/')); should(bookDetails.root).equal(run.folderPaths.notebookFolderPath.replace(/\\/g, '/'));
should(bookDetails.tableOfContents.sections).equal(undefined); should(bookDetails.tableOfContents.sections).equal(undefined);
should(bookDetails.page.sections).equal(undefined); should(bookDetails.page.sections).equal(undefined);
}; };
}); });
});
});
}); });