Merge pull request #857 from gjsjohnmurray/fix-854

support isfs copy

Author: gjsjohnmurray

src/api/index.ts

@@ -390,7 +390,8 @@ export class AtelierAPI {
         throw { statusCode: response.status, message: response.statusText, errorText: data.status.summary };
       }
       if (data.result.status && data.result.status !== "") {
-        // This is a 4XX error on a doc request
+        // This could be a 4XX error on a doc request
+        // or a 200 from a deleteDoc request for which server-side source control blocked deletion
         throw { statusCode: response.status, message: response.statusText, errorText: data.result.status };
       }
       if (response.status >= 400) {

src/providers/FileSystemProvider/FileSystemProvider.ts

@@ -15,7 +15,7 @@ declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...a
 export type Entry = File | Directory;
 
 export class FileSystemProvider implements vscode.FileSystemProvider {
-  public root = new Directory("", "");
+  private superRoot = new Directory("", "");
 
   public readonly onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]>;
 
@@ -86,9 +86,9 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
           )
           .map((item: StudioOpenDialog) => {
             const name = item.Name;
-            const fullName = folder === "" ? name : csp ? folder + name : folder + "/" + name;
             if (item.Type === "10" || item.Type === "9") {
               if (!parent.entries.has(name)) {
+                const fullName = folder === "" ? name : csp ? folder + name : folder + "/" + name;
                 parent.entries.set(name, new Directory(name, fullName));
               }
               return [name, vscode.FileType.Directory];
@@ -99,7 +99,15 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
         if (!csp) {
           return results;
         }
-        return results.concat(cspSubfolders);
+        cspSubfolders.forEach((value) => {
+          const name = value[0];
+          if (!parent.entries.has(name)) {
+            const fullName = folder + name;
+            parent.entries.set(name, new Directory(name, fullName));
+          }
+          results.push(value);
+        });
+        return results;
       })
       .catch((error) => {
         if (error) {
@@ -143,24 +151,42 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
     });
   }
 
-  private generateFileContent(fileName: string, content: Buffer): { content: string[]; enc: boolean } {
+  private generateFileContent(fileName: string, sourceContent: Buffer): { content: string[]; enc: boolean } {
+    const sourceLines = sourceContent.toString().split("\n");
     const fileExt = fileName.split(".").pop().toLowerCase();
     if (fileExt === "cls") {
       const className = fileName.split(".").slice(0, -1).join(".");
+      const content: string[] = [];
+      const preamble: string[] = [];
+
+      // If content was provided (e.g. when copying a file), use all lines except for
+      // the Class x.y one. Replace that with one to match fileName.
+      while (sourceLines.length > 0) {
+        const nextLine = sourceLines.shift();
+        if (nextLine.startsWith("Class ")) {
+          content.push(...preamble, `Class ${className}`, ...sourceLines);
+          break;
+        }
+        preamble.push(nextLine);
+      }
+      if (content.length === 0) {
+        content.push(`Class ${className}`, "{", "}");
+      }
       return {
-        content: [`Class ${className} {}`],
+        content,
         enc: false,
       };
     } else if (["int", "inc", "mac"].includes(fileExt)) {
+      sourceLines.shift();
       const routineName = fileName.split(".").slice(0, -1).join(".");
       const routineType = `[ type = ${fileExt}]`;
       return {
-        content: [`ROUTINE ${routineName} ${routineType}`],
+        content: [`ROUTINE ${routineName} ${routineType}`, ...sourceLines],
         enc: false,
       };
     }
     return {
-      content: [content.toString("base64")],
+      content: [sourceContent.toString("base64")],
       enc: true,
     };
   }
@@ -265,27 +291,42 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
     if (fileName.startsWith(".")) {
       return;
     }
+    if (!fileName.includes(".")) {
+      throw new Error(`${csp ? "Folder" : "Package"} deletion is not supported on server`);
+    }
     const api = new AtelierAPI(uri);
-    return api.deleteDoc(fileName).then((response) => {
-      if (response.result.ext) {
-        fireOtherStudioAction(OtherStudioAction.DeletedDocument, uri, response.result.ext);
+    return api.deleteDoc(fileName).then(
+      async (response) => {
+        if (response.result.ext) {
+          fireOtherStudioAction(OtherStudioAction.DeletedDocument, uri, response.result.ext);
+        }
+        // Remove entry from our cache, plus any now-empty ancestor entries
+        let thisUri = vscode.Uri.parse(uri.toString(), true);
+        const events: vscode.FileChangeEvent[] = [];
+        while (thisUri.path !== "/") {
+          events.push({ type: vscode.FileChangeType.Deleted, uri: thisUri });
+          const parentDir = await this._lookupParentDirectory(thisUri);
+          const name = path.basename(thisUri.path);
+          parentDir.entries.delete(name);
+          if (!csp && parentDir.entries.size === 0) {
+            thisUri = thisUri.with({ path: path.posix.dirname(thisUri.path) });
+          } else {
+            break;
+          }
+        }
+        this._fireSoon(...events);
+      },
+      (error) => {
+        if (error.errorText !== "") {
+          error.message = error.errorText;
+        }
+        throw error;
       }
-      // Remove entry from our cache
-      this._lookupParentDirectory(uri).then((parent) => {
-        const name = path.basename(uri.path);
-        parent.entries.delete(name);
-      });
-      this._fireSoon({ type: vscode.FileChangeType.Deleted, uri });
-    });
+    );
   }
 
   public rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: { overwrite: boolean }): void | Thenable<void> {
-    throw new Error("Not implemented");
-    return;
-  }
-  public copy?(source: vscode.Uri, destination: vscode.Uri, options: { overwrite: boolean }): void | Thenable<void> {
-    throw new Error("Not implemented");
-    return;
+    throw new Error("Move / rename is not supported on server");
   }
 
   public watch(uri: vscode.Uri): vscode.Disposable {
@@ -296,17 +337,23 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
 
   // Fetch entry (a file or directory) from cache, else from server
   private async _lookup(uri: vscode.Uri): Promise<Entry> {
+    const api = new AtelierAPI(uri);
     if (uri.path === "/") {
-      const api = new AtelierAPI(uri);
       await api
         .serverInfo()
         .then()
         .catch(() => {
           throw vscode.FileSystemError.Unavailable(`${uri.toString()} is unavailable`);
         });
     }
+    const config = api.config;
+    const rootName = `${config.username}@${config.host}:${config.port}${config.pathPrefix}/${config.ns.toUpperCase()}`;
+    let entry: Entry = this.superRoot.entries.get(rootName);
+    if (!entry) {
+      entry = new Directory(rootName, "");
+      this.superRoot.entries.set(rootName, entry);
+    }
     const parts = uri.path.split("/");
-    let entry: Entry = this.root;
     for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
       if (!part) {
@@ -317,10 +364,8 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
         child = entry.entries.get(part);
         // If the last element of path is dotted and is one we haven't already cached as a directory
         // then it is assumed to be a file.
-        if ((!part.includes(".") || i + 1 < parts.length) && !child) {
-          const fullName = entry.name === "" ? part : entry.fullName + "/" + part;
-          child = new Directory(part, fullName);
-          entry.entries.set(part, child);
+        if (!child && (!part.includes(".") || i + 1 < parts.length)) {
+          throw vscode.FileSystemError.FileNotFound(uri);
         }
       }
       if (!child) {