Replace node fs with vscode workspace.fs (#976)

isc-bsaviano · web-flow · commit 5749221adc90 · 2022-08-22T08:12:26.000-04:00
diff --git a/src/commands/compile.ts b/src/commands/compile.ts
@@ -1,4 +1,3 @@
-import fs = require("fs");
 import glob = require("glob");
 import path = require("path");
 import vscode = require("vscode");
@@ -55,14 +54,14 @@ export async function checkChangedOnServer(file: CurrentFile, force = false): Pr
     (await api
       .getDoc(file.name)
       .then((data) => data.result)
-      .then(({ ts, content }) => {
+      .then(async ({ ts, content }) => {
         const fileContent = file.content.split(/\r?\n/);
         const serverTime = Number(new Date(ts + "Z"));
         const sameContent = force
           ? false
           : content.every((line, index) => line.trim() == (fileContent[index] || "").trim());
         const mtime =
-          force || sameContent ? serverTime : Math.max(Number(fs.statSync(file.fileName).mtime), serverTime);
+          force || sameContent ? serverTime : Math.max((await vscode.workspace.fs.stat(file.uri)).mtime, serverTime);
         return mtime;
       })
       .catch(() => -1));
@@ -197,12 +196,12 @@ export async function loadChanges(files: CurrentFile[]): Promise<any> {
     files.map((file) =>
       api
         .getDoc(file.name)
-        .then((data) => {
+        .then(async (data) => {
           const content = (data.result.content || []).join(file.eol === vscode.EndOfLine.LF ? "\n" : "\r\n");
           const mtime = Number(new Date(data.result.ts + "Z"));
           workspaceState.update(`${file.uniqueId}:mtime`, mtime > 0 ? mtime : undefined);
           if (file.uri.scheme === "file") {
-            fs.writeFileSync(file.fileName, content);
+            await vscode.workspace.fs.writeFile(file.uri, new TextEncoder().encode(content));
           } else if (file.uri.scheme === FILESYSTEM_SCHEMA || file.uri.scheme === FILESYSTEM_READONLY_SCHEMA) {
             fileSystemProvider.fireFileChanged(file.uri);
           }
@@ -398,12 +397,13 @@ export async function namespaceCompile(askFlags = false): Promise<any> {
   );
 }
 
-function importFiles(files, noCompile = false) {
+function importFiles(files: string[], noCompile = false) {
   return Promise.all<CurrentFile>(
     files.map(
-      throttleRequests((file) =>
-        fs.promises
-          .readFile(file, { encoding: "utf8" })
+      throttleRequests((file: string) =>
+        vscode.workspace.fs
+          .readFile(vscode.Uri.file(file))
+          .then((contentBytes) => new TextDecoder().decode(contentBytes))
           .then((content) => currentFileFromContent(file, content))
           .then((curFile) =>
             importFile(curFile).then((data) => {
@@ -418,7 +418,7 @@ function importFiles(files, noCompile = false) {
 
 export async function importFolder(uri: vscode.Uri, noCompile = false): Promise<any> {
   const uripath = uri.fsPath;
-  if (fs.lstatSync(uripath).isFile()) {
+  if ((await vscode.workspace.fs.stat(uri)).type != vscode.FileType.Directory) {
     return importFiles([uripath], noCompile);
   }
   let globpattern = "*.{cls,inc,int,mac}";
diff --git a/src/commands/export.ts b/src/commands/export.ts
@@ -1,9 +1,8 @@
-import fs = require("fs");
 import path = require("path");
 import * as vscode from "vscode";
 import { AtelierAPI } from "../api";
 import { config, explorerProvider, OBJECTSCRIPT_FILE_SCHEMA, schemas } from "../extension";
-import { currentFile, mkdirSyncRecursive, notNull, outputChannel, uriOfWorkspaceFolder } from "../utils";
+import { currentFile, fileExists, notNull, outputChannel, uriOfWorkspaceFolder } from "../utils";
 import { NodeBase } from "../explorer/models/nodeBase";
 
 export const getCategory = (fileName: string, addCategory: any | boolean): string => {
@@ -99,92 +98,96 @@ export async function exportFile(
   const api = new AtelierAPI(workspaceFolder);
   api.setNamespace(namespace);
   const log = (status) => outputChannel.appendLine(`export "${name}" as "${fileName}" - ${status}`);
-  const folders = path.dirname(fileName);
-  return mkdirSyncRecursive(folders)
-    .then(() => {
-      return api.getDoc(name).then((data) => {
-        if (!data || !data.result) {
-          throw new Error("Something wrong happened");
-        }
-        const content = data.result.content;
-        const { noStorage, dontExportIfNoChanges } = config("export");
+  const foldersUri = vscode.Uri.file(path.dirname(fileName));
+  try {
+    if (!(await fileExists(foldersUri))) {
+      // Only attempt to create directories that don't exist
+      await vscode.workspace.fs.createDirectory(foldersUri);
+    }
 
-        const promise = new Promise((resolve, reject) => {
-          if (noStorage) {
-            // get only the storage xml for the doc.
-            api.getDoc(name + "?storageOnly=1").then((storageData) => {
-              if (!storageData || !storageData.result) {
-                reject(new Error("Something wrong happened fetching the storage data"));
-              }
-              const storageContent = storageData.result.content;
+    api.getDoc(name).then((data) => {
+      if (!data || !data.result) {
+        throw new Error("Something wrong happened");
+      }
+      const content = data.result.content;
+      const { noStorage, dontExportIfNoChanges } = config("export");
 
-              if (storageContent.length > 1 && storageContent[0] && storageContent.length < content.length) {
-                const storageContentString = storageContent.join("\n");
-                const contentString = content.join("\n");
+      const promise = new Promise((resolve, reject) => {
+        if (noStorage) {
+          // get only the storage xml for the doc.
+          api.getDoc(name + "?storageOnly=1").then((storageData) => {
+            if (!storageData || !storageData.result) {
+              reject(new Error("Something wrong happened fetching the storage data"));
+            }
+            const storageContent = storageData.result.content;
 
-                // find and replace the docs storage section with ''
-                resolve({
-                  content: contentString.replace(storageContentString, ""),
-                  found: contentString.indexOf(storageContentString) >= 0,
-                });
-              } else {
-                resolve({ found: false });
-              }
-            });
-          } else {
-            resolve({ found: false });
-          }
-        });
+            if (storageContent.length > 1 && storageContent[0] && storageContent.length < content.length) {
+              const storageContentString = storageContent.join("\n");
+              const contentString = content.join("\n");
+
+              // find and replace the docs storage section with ''
+              resolve({
+                content: contentString.replace(storageContentString, ""),
+                found: contentString.indexOf(storageContentString) >= 0,
+              });
+            } else {
+              resolve({ found: false });
+            }
+          });
+        } else {
+          resolve({ found: false });
+        }
+      });
 
-        return promise
-          .then((res: any) => {
-            if (Buffer.isBuffer(content)) {
-              // This is a binary file
-              let isSkipped = "";
-              if (dontExportIfNoChanges && fs.existsSync(fileName)) {
-                const existingContent = fs.readFileSync(fileName);
-                if (content.equals(existingContent)) {
-                  fs.writeFileSync(fileName, content);
-                } else {
-                  isSkipped = " => skipped - no changes.";
-                }
+      return promise
+        .then(async (res: any) => {
+          const fileUri = vscode.Uri.file(fileName);
+          if (Buffer.isBuffer(content)) {
+            // This is a binary file
+            let isSkipped = "";
+            if (dontExportIfNoChanges && (await fileExists(fileUri))) {
+              const existingContent = await vscode.workspace.fs.readFile(fileUri);
+              if (content.equals(existingContent)) {
+                await vscode.workspace.fs.writeFile(fileUri, content);
               } else {
-                fs.writeFileSync(fileName, content);
+                isSkipped = " => skipped - no changes.";
               }
-              log(`Success ${isSkipped}`);
             } else {
-              // This is a text file
-              let joinedContent = content.join("\n");
-              let isSkipped = "";
+              await vscode.workspace.fs.writeFile(fileUri, content);
+            }
+            log(`Success ${isSkipped}`);
+          } else {
+            // This is a text file
+            let joinedContent = content.join("\n");
+            let isSkipped = "";
 
-              if (res.found) {
-                joinedContent = res.content.toString("utf8");
-              }
+            if (res.found) {
+              joinedContent = res.content.toString("utf8");
+            }
 
-              if (dontExportIfNoChanges && fs.existsSync(fileName)) {
-                const existingContent = fs.readFileSync(fileName, "utf8");
-                // stringify to harmonise the text encoding.
-                if (JSON.stringify(joinedContent) !== JSON.stringify(existingContent)) {
-                  fs.writeFileSync(fileName, joinedContent);
-                } else {
-                  isSkipped = " => skipped - no changes.";
-                }
+            if (dontExportIfNoChanges && (await fileExists(fileUri))) {
+              const existingContent = new TextDecoder().decode(await vscode.workspace.fs.readFile(fileUri));
+              // stringify to harmonise the text encoding.
+              if (JSON.stringify(joinedContent) !== JSON.stringify(existingContent)) {
+                await vscode.workspace.fs.writeFile(fileUri, new TextEncoder().encode(joinedContent));
               } else {
-                fs.writeFileSync(fileName, joinedContent);
+                isSkipped = " => skipped - no changes.";
               }
-
-              log(`Success ${isSkipped}`);
+            } else {
+              await vscode.workspace.fs.writeFile(fileUri, new TextEncoder().encode(joinedContent));
             }
-          })
-          .catch((error) => {
-            throw error;
-          });
-      });
-    })
-    .catch((error) => {
-      log("ERROR: " + error);
-      throw error;
+
+            log(`Success ${isSkipped}`);
+          }
+        })
+        .catch((error) => {
+          throw error;
+        });
     });
+  } catch (error) {
+    log("ERROR: " + error);
+    throw error;
+  }
 }
 
 export async function exportList(files: string[], workspaceFolder: string, namespace: string): Promise<any> {
diff --git a/src/utils/index.ts b/src/utils/index.ts
@@ -1,6 +1,4 @@
-import fs = require("fs");
 import path = require("path");
-import { R_OK } from "constants";
 import * as url from "url";
 import { exec } from "child_process";
 import * as vscode from "vscode";
@@ -266,29 +264,6 @@ export function currentFile(document?: vscode.TextDocument): CurrentFile {
   };
 }
 
-export async function mkdirSyncRecursive(dirpath: string): Promise<string> {
-  if (fs.existsSync(dirpath)) {
-    return Promise.resolve(dirpath);
-  }
-  const mkdir = (currentPath, folder): void => {
-    currentPath += folder + path.sep;
-
-    if (!fs.existsSync(currentPath)) {
-      fs.mkdirSync(currentPath);
-    }
-
-    return currentPath;
-  };
-  return new Promise<string>((resolve, reject): void => {
-    try {
-      dirpath.split(path.sep).reduce(mkdir, "");
-      resolve(dirpath);
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-
 export function connectionTarget(uri?: vscode.Uri): ConnectionTarget {
   const result: ConnectionTarget = { apiTarget: "", configName: "" };
   uri = uri
@@ -425,20 +400,12 @@ export async function portFromDockerCompose(): Promise<{ port: number; docker: b
   const workspaceFolderPath = uriOfWorkspaceFolder().fsPath;
   const workspaceRootPath = vscode.workspace.workspaceFolders[0].uri.fsPath;
 
-  const cwd: string = await new Promise((resolve, reject) => {
-    fs.access(path.join(workspaceFolderPath, file), R_OK, (error) => {
-      if (error) {
-        fs.access(path.join(workspaceRootPath, file), R_OK, (error) => {
-          if (error) {
-            reject(new Error(`File '${file}' not found.`));
-          } else {
-            resolve(workspaceRootPath);
-          }
-        });
-      } else {
-        resolve(workspaceFolderPath);
-      }
-    });
+  const cwd: string = await fileExists(vscode.Uri.file(path.join(workspaceFolderPath, file))).then((exists) => {
+    if (exists) {
+      return workspaceRootPath;
+    } else {
+      throw new Error(`File '${file}' not found.`);
+    }
   });
 
   if (!cwd) {
@@ -554,6 +521,17 @@ export function redirectDotvscodeRoot(uri: vscode.Uri): vscode.Uri {
   }
 }
 
+/** Check if local `file` exists using vscode's `workspace.fs` FileSystem. */
+export async function fileExists(file: vscode.Uri): Promise<boolean> {
+  try {
+    vscode.workspace.fs.stat(file);
+    return true;
+  } catch {
+    // Only error thown is "FileNotFound"
+    return false;
+  }
+}
+
 // ---------------------------------------------------------------------
 // Source: https://github.com/amsterdamharu/lib/blob/master/src/index.js
 
