Merge pull request #11 from martinRenou/add_support_opening_subdirs

Add support opening subdirs

Author: jtpio

src/drive.ts

@@ -1,7 +1,21 @@
 import { Contents, ServerConnection } from '@jupyterlab/services';
 
+import { PathExt } from '@jupyterlab/coreutils';
+
 import { ISignal, Signal } from '@lumino/signaling';
 
+async function toArray<T>(
+  asyncIterator: AsyncIterableIterator<T>
+): Promise<T[]> {
+  const arr = [];
+
+  for await (const i of asyncIterator) {
+    arr.push(i);
+  }
+
+  return arr;
+}
+
 export class FileSystemDrive implements Contents.IDrive {
   get isDisposed(): boolean {
     return this._isDisposed;
@@ -36,7 +50,7 @@ export class FileSystemDrive implements Contents.IDrive {
   }
 
   async get(
-    localPath: string,
+    path: string,
     options?: Contents.IFetchOptions
   ): Promise<Contents.IModel> {
     const root = this._rootHandle;
@@ -55,12 +69,33 @@ export class FileSystemDrive implements Contents.IDrive {
       };
     }
 
+    let parentHandle = root;
+    // If requesting a file/directory that is not under root, we need the right directory handle
+    for (const subPath of path.split('/').slice(0, -1)) {
+      parentHandle = await parentHandle.getDirectoryHandle(subPath);
+    }
+
+    const parentPath = PathExt.dirname(path);
+    const localPath = PathExt.basename(path);
+
+    let localHandle: FileSystemDirectoryHandle | FileSystemFileHandle;
+
+    const currentContent = await toArray(parentHandle.values());
+
     if (localPath) {
-      const handle = await root.getFileHandle(localPath);
-      const file = await handle.getFile();
+      localHandle = currentContent.filter(
+        element => element.name === localPath
+      )[0];
+    } else {
+      localHandle = parentHandle;
+    }
+
+    if (localHandle.kind === 'file') {
+      const file = await localHandle.getFile();
+
       return {
         name: file.name,
-        path: file.name,
+        path: PathExt.join(parentPath, localPath),
         created: new Date(file.lastModified).toISOString(),
         last_modified: new Date(file.lastModified).toISOString(),
         format: 'text',
@@ -69,72 +104,71 @@ export class FileSystemDrive implements Contents.IDrive {
         type: 'file',
         mimetype: 'text/plain'
       };
-    }
-
-    const content: Contents.IModel[] = [];
-
-    for await (const value of root.values()) {
-      if (value.kind === 'file') {
-        const file = await value.getFile();
-        content.push({
-          name: file.name,
-          path: file.name,
-          created: new Date(file.lastModified).toISOString(),
-          last_modified: new Date(file.lastModified).toISOString(),
-          format: 'text',
-          content: await file.text(),
-          writable: true,
-          type: 'file',
-          mimetype: 'text/plain'
-        });
-      } else {
-        content.push({
-          name: value.name,
-          path: value.name,
-          created: new Date().toISOString(),
-          last_modified: new Date().toISOString(),
-          format: 'json',
-          content: null,
-          writable: true,
-          type: 'directory',
-          mimetype: 'application/json'
-        });
+    } else {
+      const content: Contents.IModel[] = [];
+
+      for await (const value of localHandle.values()) {
+        if (value.kind === 'file') {
+          const file = await value.getFile();
+          content.push({
+            name: file.name,
+            path: PathExt.join(parentPath, localPath, file.name),
+            created: new Date(file.lastModified).toISOString(),
+            last_modified: new Date(file.lastModified).toISOString(),
+            format: 'text',
+            content: await file.text(),
+            writable: true,
+            type: 'file',
+            mimetype: 'text/plain'
+          });
+        } else {
+          content.push({
+            name: value.name,
+            path: PathExt.join(parentPath, localPath, value.name),
+            created: '',
+            last_modified: '',
+            format: 'json',
+            content: null,
+            writable: true,
+            type: 'directory',
+            mimetype: 'application/json'
+          });
+        }
       }
-    }
 
-    const date = new Date();
-    return {
-      name: 'root',
-      path: '',
-      last_modified: date.toISOString(),
-      created: date.toISOString(),
-      format: 'json',
-      mimetype: 'application/json',
-      content,
-      size: undefined,
-      writable: true,
-      type: 'directory'
-    };
+      return {
+        name: PathExt.basename(parentPath),
+        path: PathExt.join(parentPath, localPath),
+        last_modified: '',
+        created: '',
+        format: 'json',
+        mimetype: 'application/json',
+        content,
+        size: undefined,
+        writable: true,
+        type: 'directory'
+      };
+    }
   }
 
-  getDownloadUrl(localPath: string): Promise<string> {
+  getDownloadUrl(path: string): Promise<string> {
     throw new Error('Method not implemented.');
   }
 
   newUntitled(options?: Contents.ICreateOptions): Promise<Contents.IModel> {
     throw new Error('Method not implemented.');
   }
 
-  delete(localPath: string): Promise<void> {
+  delete(path: string): Promise<void> {
     throw new Error('Method not implemented.');
   }
 
-  rename(oldLocalPath: string, newLocalPath: string): Promise<Contents.IModel> {
+  rename(oldPath: string, newPath: string): Promise<Contents.IModel> {
     throw new Error('Method not implemented.');
   }
 
   async save(
-    localPath: string,
+    path: string,
     options?: Partial<Contents.IModel>
   ): Promise<Contents.IModel> {
     const root = this._rootHandle;
@@ -143,7 +177,13 @@ export class FileSystemDrive implements Contents.IDrive {
       throw new Error('No root file handle');
     }
 
-    const handle = await root.getFileHandle(localPath);
+    let parentHandle = root;
+    // If saving a file that is not under root, we need the right directory handle
+    for (const subPath of path.split('/').slice(0, -1)) {
+      parentHandle = await parentHandle.getDirectoryHandle(subPath);
+    }
+
+    const handle = await parentHandle.getFileHandle(PathExt.basename(path));
     const writable = await handle.createWritable({});
 
     const format = options?.format;
@@ -155,25 +195,21 @@ export class FileSystemDrive implements Contents.IDrive {
       await writable.write(content);
     }
     await writable.close();
-    return this.get(localPath);
+    return this.get(path);
   }
 
-  copy(localPath: string, toLocalDir: string): Promise<Contents.IModel> {
+  copy(path: string, toLocalDir: string): Promise<Contents.IModel> {
     throw new Error('Method not implemented.');
   }
 
-  async createCheckpoint(
-    localPath: string
-  ): Promise<Contents.ICheckpointModel> {
+  async createCheckpoint(path: string): Promise<Contents.ICheckpointModel> {
     return {
       id: 'test',
       last_modified: new Date().toISOString()
     };
   }
 
-  async listCheckpoints(
-    localPath: string
-  ): Promise<Contents.ICheckpointModel[]> {
+  async listCheckpoints(path: string): Promise<Contents.ICheckpointModel[]> {
     return [
       {
         id: 'test',
@@ -182,11 +218,11 @@ export class FileSystemDrive implements Contents.IDrive {
     ];
   }
 
-  restoreCheckpoint(localPath: string, checkpointID: string): Promise<void> {
+  restoreCheckpoint(path: string, checkpointID: string): Promise<void> {
     return Promise.resolve(void 0);
   }
 
-  deleteCheckpoint(localPath: string, checkpointID: string): Promise<void> {
+  deleteCheckpoint(path: string, checkpointID: string): Promise<void> {
     return Promise.resolve(void 0);
   }
 

src/index.ts

@@ -42,18 +42,23 @@ const plugin: JupyterFrontEndPlugin<void> = {
     serviceManager.contents.addDrive(drive);
 
     const widget = createFileBrowser('jp-filesystem-browser', {
-      driveName: drive.name
+      driveName: drive.name,
+      // We don't want to restore old state, we don't have a drive handle ready
+      restore: false
     });
     widget.title.caption = trans.__('Local File System');
     widget.title.icon = listIcon;
 
     const openDirectoryButton = new ToolbarButton({
       icon: folderIcon,
       onClick: async () => {
-        const fileHandle = await window.showDirectoryPicker();
+        const directoryHandle = await window.showDirectoryPicker();
 
-        if (fileHandle) {
-          drive.rootHandle = fileHandle;
+        if (directoryHandle) {
+          drive.rootHandle = directoryHandle;
+
+          // Go to root directory
+          widget.model.cd('/');
         }
       },
       tooltip: trans.__('Open a new folder')