Use the new API for mkdirp().

Author: ericsnowcurrently

src/client/common/platform/fileSystem.ts

@@ -23,6 +23,17 @@ import {
 
 const ENCODING: string = 'utf8';
 
+const FILE_NOT_FOUND = vscode.FileSystemError.FileNotFound().name;
+const FILE_EXISTS = vscode.FileSystemError.FileExists().name;
+
+function isFileNotFoundError(err: Error): boolean {
+    return err.name === FILE_NOT_FOUND;
+}
+
+function isFileExistsError(err: Error): boolean {
+    return err.name === FILE_EXISTS;
+}
+
 function convertFileStat(stat: fsextra.Stats): FileStat {
     let fileType = FileType.Unknown;
     if (stat.isFile()) {
@@ -42,6 +53,7 @@ function convertFileStat(stat: fsextra.Stats): FileStat {
 
 interface INodePath {
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normalize(filename: string): string;
 }
 
@@ -57,6 +69,10 @@ export class FileSystemPath implements IFileSystemPath {
         return this.raw.join(...filenames);
     }
 
+    public dirname(filename: string): string {
+        return this.raw.dirname(filename);
+    }
+
     public normCase(filename: string): string {
         filename = this.raw.normalize(filename);
         return this.isWindows ? filename.toUpperCase() : filename;
@@ -97,7 +113,7 @@ export class TempFileSystem {
 // This is the parts of the vscode.workspace.fs API that we use here.
 interface INewAPI {
     copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
-    //createDirectory(uri: vscode.Uri): Thenable<void>;
+    createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
@@ -119,23 +135,22 @@ interface IRawFS {
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
 
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
 }
 
-//interface IRawPath {
-//    join(...filenames: string[]): string;
-//}
+interface IRawPath {
+    dirname(filename: string): string;
+}
 
 // Later we will drop "FileSystem", switching usage to
 // "FileSystemUtils" and then rename "RawFileSystem" to "FileSystem".
 
 export class RawFileSystem implements IRawFileSystem {
     constructor(
-        //private readonly path: IRawPath = new FileSystemPath(),
+        private readonly path: IRawPath = new FileSystemPath(),
         private readonly newapi: INewAPI = vscode.workspace.fs,
         private readonly nodefs: IRawFS = fs,
         private readonly fsExtra: IRawFSExtra = fsextra
@@ -183,6 +198,37 @@ export class RawFileSystem implements IRawFileSystem {
         return this.newapi.readDirectory(uri);
     }
 
+    public async mkdirp(dirname: string): Promise<void> {
+        const stack = [dirname];
+        while (stack.length > 0) {
+            const current = stack.pop() || '';
+            const uri = vscode.Uri.file(current);
+            try {
+                await this.newapi.createDirectory(uri);
+            } catch (err) {
+                if (isFileExistsError(err)) {
+                    // already done!
+                    return;
+                }
+                // According to the docs, FileNotFound means the parent
+                // does not exist.
+                // See: https://code.visualstudio.com/api/references/vscode-api#FileSystemProvider
+                if (!isFileNotFoundError(err)) {
+                    // Fail for anything else.
+                    throw err; // re-throw
+                }
+                // Try creating the parent first.
+                const parent = this.path.dirname(current);
+                if (parent === '' || parent === current) {
+                    // This shouldn't ever happen.
+                    throw err;
+                }
+                stack.push(current);
+                stack.push(parent);
+            }
+        }
+    }
+
     public async copyFile(src: string, dest: string): Promise<void> {
         const srcURI = vscode.Uri.file(src);
         const destURI = vscode.Uri.file(dest);
@@ -194,10 +240,6 @@ export class RawFileSystem implements IRawFileSystem {
     //****************************
     // fs-extra
 
-    public async mkdirp(dirname: string): Promise<void> {
-        return this.fsExtra.mkdirp(dirname);
-    }
-
     public async chmod(filename: string, mode: string | number): Promise<void> {
         return this.fsExtra.chmod(filename, mode);
     }

src/client/common/platform/types.ts

@@ -50,6 +50,14 @@ export interface IFileSystemPath {
     normCase(filename: string): string;
 }
 
+// Eventually we will merge IPathUtils into IFileSystemPath.
+
+export interface IFileSystemPath {
+    join(...filenames: string[]): string;
+    dirname(filename: string): string;
+    normCase(filename: string): string;
+}
+
 export import FileType = vscode.FileType;
 export type FileStat = vscode.FileStat;
 export type WriteStream = fs.WriteStream;

src/test/common/platform/filesystem.functional.test.ts

@@ -194,28 +194,6 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
-    suite('mkdirp', () => {
-        test('creates the directory and all missing parents', async () => {
-            await fix.createDirectory('x');
-            // x/y, x/y/z, and x/y/z/spam are all missing.
-            const dirname = await fix.resolve('x/y/z/spam', false);
-            await ensureDoesNotExist(dirname);
-
-            await filesystem.mkdirp(dirname);
-
-            await fsextra.stat(dirname); // This should not fail.
-        });
-
-        test('works if the directory already exists', async () => {
-            const dirname = await fix.createDirectory('spam');
-            await fsextra.stat(dirname); // This should not fail.
-
-            await filesystem.mkdirp(dirname);
-
-            await fsextra.stat(dirname); // This should not fail.
-        });
-    });
-
     suite('chmod (non-Windows)', () => {
         suiteSetup(function () {
             // On Windows, chmod won't have any effect on the file itself.

src/test/common/platform/filesystem.test.ts

@@ -240,6 +240,28 @@ suite('Raw FileSystem', () => {
         });
     });
 
+    suite('mkdirp', () => {
+        test('creates the directory and all missing parents', async () => {
+            await fix.createDirectory('x');
+            // x/y, x/y/z, and x/y/z/spam are all missing.
+            const dirname = await fix.resolve('x/y/z/spam', false);
+            await ensureDoesNotExist(dirname);
+
+            await filesystem.mkdirp(dirname);
+
+            await fsextra.stat(dirname); // This should not fail.
+        });
+
+        test('works if the directory already exists', async () => {
+            const dirname = await fix.createDirectory('spam');
+            await fsextra.stat(dirname); // This should not fail.
+
+            await filesystem.mkdirp(dirname);
+
+            await fsextra.stat(dirname); // This should not fail.
+        });
+    });
+
     suite('copyFile', () => {
         test('the source file gets copied (same directory)', async () => {
             const data = '<content>';

src/test/common/platform/filesystem.unit.test.ts

@@ -5,7 +5,7 @@ import { expect } from 'chai';
 import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Uri } from 'vscode';
+import { Disposable, FileSystemError, Uri } from 'vscode';
 import {
     FileSystemPath, FileSystemUtils, RawFileSystem, TempFileSystem
 } from '../../../client/common/platform/fileSystem';
@@ -22,6 +22,7 @@ type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () =>
 interface IRawFS {
     // VS Code
     copy(source: Uri, target: Uri, options?: {overwrite: boolean}): Thenable<void>;
+    createDirectory(uri: Uri): Thenable<void>;
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
@@ -38,7 +39,6 @@ interface IRawFS {
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
 
@@ -122,6 +122,19 @@ suite('FileSystem paths', () => {
         });
     });
 
+    suite('dirname', () => {
+        test('wraps low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = 'x/y/z';
+            raw.setup(r => r.dirname(filename))
+                .returns(() => expected);
+
+            const result = path.dirname(filename);
+
+            expect(result).to.equal(expected);
+        });
+    });
+
     suite('normCase', () => {
         test('wraps low-level function', () => {
             const filename = 'x/y/z/spam.py';
@@ -249,6 +262,7 @@ suite('Raw FileSystem', () => {
             //raw.object,
             raw.object,
             raw.object,
+            raw.object,
             raw.object
         );
 
@@ -367,8 +381,34 @@ suite('Raw FileSystem', () => {
     suite('mkdirp', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.mkdirp(dirname))
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve());
+
+            await filesystem.mkdirp(dirname);
+
+            verifyAll();
+        });
+
+        test('creates missing parent directories', async () => {
+            const dirname = 'x/y/z/spam';
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .throws(FileSystemError.FileNotFound(dirname))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname(dirname))
+                .returns(() => 'x/y/z');
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .throws(FileSystemError.FileNotFound('x/y/z'))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname('x/y/z'))
+                .returns(() => 'x/y');
+            raw.setup(r => r.createDirectory(Uri.file('x/y')))
                 .returns(() => Promise.resolve());
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
 
             await filesystem.mkdirp(dirname);
 

src/test/vscode-mock.ts

@@ -82,6 +82,7 @@ mockedVSCode.CodeActionKind = vscodeMocks.vscMock.CodeActionKind;
 mockedVSCode.DebugAdapterExecutable = vscodeMocks.vscMock.DebugAdapterExecutable;
 mockedVSCode.DebugAdapterServer = vscodeMocks.vscMock.DebugAdapterServer;
 mockedVSCode.FileType = vscodeMocks.vscMock.FileType;
+mockedVSCode.FileSystemError = vscodeMocks.vscMockExtHostedTypes.FileSystemError;
 
 // This API is used in src/client/telemetry/telemetry.ts
 const extensions = TypeMoq.Mock.ofType<typeof vscode.extensions>();