Use the new API for stat (async-only and not lstat).

Author: ericsnowcurrently

src/client/common/platform/fileSystem.ts

@@ -23,6 +23,23 @@ import {
 
 const ENCODING: string = 'utf8';
 
+function convertFileStat(stat: fsextra.Stats): FileStat {
+    let fileType = FileType.Unknown;
+    if (stat.isFile()) {
+        fileType = FileType.File;
+    } else if (stat.isDirectory()) {
+        fileType = FileType.Directory;
+    } else if (stat.isSymbolicLink()) {
+        fileType = FileType.SymbolicLink;
+    }
+    return {
+        type: fileType,
+        size: stat.size,
+        ctime: stat.ctimeMs,
+        mtime: stat.mtimeMs
+    };
+}
+
 // 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>;
@@ -31,7 +48,7 @@ interface INewAPI {
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
     readFile(uri: vscode.Uri): Thenable<Uint8Array>;
     //rename(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
-    //stat(uri: vscode.Uri): Thenable<vscode.FileStat>;
+    stat(uri: vscode.Uri): Thenable<FileStat>;
     //writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }
 
@@ -49,7 +66,6 @@ interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
     //tslint:disable-next-line:no-any
     writeFile(path: string, data: any, options: any): Promise<void>;
-    stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
 
@@ -96,6 +112,11 @@ export class RawFileSystem implements IRawFileSystem {
         });
     }
 
+    public async stat(filename: string): Promise<FileStat> {
+        const uri = vscode.Uri.file(filename);
+        return this.newapi.stat(uri);
+    }
+
     public async listdir(dirname: string): Promise<[string, FileType][]> {
         const uri = vscode.Uri.file(dirname);
         return this.newapi.readDirectory(uri);
@@ -119,12 +140,10 @@ export class RawFileSystem implements IRawFileSystem {
         return this.fsExtra.chmod(filename, mode);
     }
 
-    public async stat(filename: string): Promise<FileStat> {
-        return this.fsExtra.stat(filename);
-    }
-
     public async lstat(filename: string): Promise<FileStat> {
-        return this.fsExtra.lstat(filename);
+        // At the moment the new VS Code API does not seem to support lstat...
+        const stat = await this.fsExtra.lstat(filename);
+        return convertFileStat(stat);
     }
 
     public async copyFile(src: string, dest: string): Promise<void> {
@@ -165,7 +184,8 @@ export class RawFileSystem implements IRawFileSystem {
     // non-async (fs-extra)
 
     public statSync(filename: string): FileStat {
-        return this.fsExtra.statSync(filename);
+        const stat = this.fsExtra.statSync(filename);
+        return convertFileStat(stat);
     }
 
     public readTextSync(filename: string): string {
@@ -262,15 +282,11 @@ export class FileSystemUtils implements IFileSystemUtils {
         } catch (err) {
             return false;
         }
+
         if (fileType === undefined) {
             return true;
-        } else if (fileType === FileType.File) {
-            return stat.isFile();
-        } else if (fileType === FileType.Directory) {
-            return stat.isDirectory();
-        } else {
-            return false;
         }
+        return stat.type === fileType;
     }
     public async fileExists(filename: string): Promise<boolean> {
         return this.pathExists(filename, FileType.File);
@@ -320,7 +336,7 @@ export class FileSystemUtils implements IFileSystemUtils {
 
     public async getFileHash(filename: string): Promise<string> {
         const stat = await this.raw.lstat(filename);
-        const data = `${stat.ctimeMs}-${stat.mtimeMs}`;
+        const data = `${stat.ctime}-${stat.mtime}`;
         return this.getHash(data);
     }
 
@@ -367,12 +383,8 @@ export class FileSystem extends FileSystemUtils implements IFileSystem {
     //****************************
     // aliases
 
-    public async stat(filePath: string): Promise<vscode.FileStat> {
-        // Do not import vscode directly, as this isn't available in the Debugger Context.
-        // If stat is used in debugger context, it will fail, however theres a separate PR that will resolve this.
-        // tslint:disable-next-line: no-require-imports
-        const vsc = require('vscode');
-        return vsc.workspace.fs.stat(vscode.Uri.file(filePath));
+    public async stat(filePath: string): Promise<FileStat> {
+        return this.raw.stat(filePath);
     }
 
     public async readFile(filename: string): Promise<string> {

src/client/common/platform/types.ts

@@ -4,7 +4,6 @@
 'use strict';
 
 import * as fs from 'fs';
-import * as fsextra from 'fs-extra';
 import { SemVer } from 'semver';
 import * as vscode from 'vscode';
 import { Architecture, OSType } from '../utils/platform';
@@ -42,7 +41,7 @@ export type TemporaryDirectory = vscode.Disposable & {
 };
 
 export import FileType = vscode.FileType;
-export type FileStat = fsextra.Stats;
+export type FileStat = vscode.FileStat;
 export type WriteStream = fs.WriteStream;
 
 // Later we will drop "IFileSystem", switching usage to
@@ -101,7 +100,7 @@ export interface IFileSystemUtils {
 // more aliases (to cause less churn)
 export const IFileSystem = Symbol('IFileSystem');
 export interface IFileSystem extends IFileSystemUtils {
-    stat(filePath: string): Promise<vscode.FileStat>;
+    stat(filePath: string): Promise<FileStat>;
     readFile(filename: string): Promise<string>;
     writeFile(filename: string, data: {}): Promise<void>;
     chmod(filename: string, mode: string): Promise<void>;

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

@@ -218,47 +218,17 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('stat', () => {
-        test('gets the info for an existing file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
-
-            const stat = await filesystem.stat(filename);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('gets the info for an existing directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-            const expected = await fsextra.stat(dirname);
-
-            const stat = await filesystem.stat(dirname);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('for symlinks, gets the info for the linked file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
-
-            const stat = await filesystem.stat(symlink);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('fails if the file does not exist', async () => {
-            const promise = filesystem.stat(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('lstat', () => {
         test('for symlinks, gives the link info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.lstat(symlink);
+            const old = await fsextra.lstat(symlink);
+            const expected = {
+                type: FileType.SymbolicLink,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(symlink);
 
@@ -267,7 +237,13 @@ suite('Raw FileSystem', () => {
 
         test('for normal files, gives the file info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(filename);
 
@@ -356,7 +332,13 @@ suite('Raw FileSystem', () => {
     suite('statSync', () => {
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(filename);
 
@@ -365,7 +347,13 @@ suite('Raw FileSystem', () => {
 
         test('gets the info for an existing directory', async () => {
             const dirname = await fix.createDirectory('x/y/z/spam');
-            const expected = await fsextra.stat(dirname);
+            const old = await fsextra.stat(dirname);
+            const expected = {
+                type: FileType.Directory,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(dirname);
 
@@ -375,7 +363,13 @@ suite('Raw FileSystem', () => {
         test('for symlinks, gets the info for the linked file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(symlink);
 
@@ -632,100 +626,6 @@ suite('FileSystem Utils', () => {
         }
     });
 
-    suite('pathExists', () => {
-        test('file missing (any})', async () => {
-            const exists = await utils.pathExists(DOES_NOT_EXIST);
-
-            expect(exists).to.equal(false);
-        });
-
-        Object.keys(FileType).forEach(ft => {
-            test(`file missing (${ft})`, async () => {
-                //tslint:disable-next-line:no-any
-                const exists = await utils.pathExists(DOES_NOT_EXIST, ft as any as FileType);
-
-                expect(exists).to.equal(false);
-            });
-        });
-
-        test('any', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, not file', async () => {
-            const filename = await fix.createDirectory('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want directory, not directory', async () => {
-            const dirname = await fix.createFile('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('symlink', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-
-            const exists = await utils.pathExists(symlink, FileType.SymbolicLink);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('unknown', async () => {
-            const sockFile = await fix.createSocket('x/y/z/ipc.sock');
-
-            const exists = await utils.pathExists(sockFile, FileType.Unknown);
-
-            expect(exists).to.equal(false);
-        });
-    });
-
-    suite('fileExists', () => {
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.fileExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
-    suite('directoryExists', () => {
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.directoryExists(dirname);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
     suite('pathExistsSync', () => {
         test('exists', async () => {
             const filename = await fix.createFile('x/y/z/spam.py');