Allow Save As and breadcrumb navigation

src/api/IBMiContent.ts

@@ -25,7 +25,6 @@ export type SortOptions = {
 }
 
 export default class IBMiContent {
-  private chgJobCCSID: string | undefined = undefined;
   constructor(readonly ibmi: IBMi) { }
 
   private get config(): ConnectionConfiguration.Parameters {
@@ -878,7 +877,7 @@ export default class IBMiContent {
     })).code === 0;
   }
 
-  async testStreamFile(path: string, right: "f" | "d" | "r" | "w" | "x") {
+  async testStreamFile(path: string, right: "e" | "f" | "d" | "r" | "w" | "x") {
     return (await this.ibmi.sendCommand({ command: `test -${right} ${Tools.escapePath(path)}` })).code === 0;
   }
 
@@ -944,4 +943,17 @@ export default class IBMiContent {
   async countFiles(directory: string) {
     return Number((await this.ibmi.sendCommand({ command: `ls | wc -l`, directory })).stdout.trim());
   }
+
+  /**
+   * Creates an empty unicode streamfile
+   * @param path the full path to the streamfile
+   * @throws an Error if the file could not be correctly created
+   */
+  async createStreamFile(path: string) {
+    path = Tools.escapePath(path);
+    const result = (await this.ibmi.sendCommand({ command: `echo "" > ${path} && ${this.ibmi.remoteFeatures.attr} ${path} CCSID=1208` }));
+    if (result.code !== 0) {
+      throw new Error(result.stderr);
+    }
+  }
 }

src/api/Tools.ts

@@ -6,6 +6,9 @@ import { t } from "../locale";
 import { IBMiMessage, IBMiMessages, QsysPath } from '../typings';
 import { API, GitExtension } from "./import/git";
 
+const MONTHS = [undefined, "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
+const DAYS = [undefined,"Mon","Tue","Wed","Thu","Fri","Sat","Sun"];
+
 export namespace Tools {
   export class SqlError extends Error {
     public sqlstate: string = "0";
@@ -174,11 +177,11 @@ export namespace Tools {
    */
   export function qualifyPath(library: string, object: string, member?: string, iasp?: string, sanitise?: boolean) {
     const libraryPath = library === `QSYS` ? `QSYS.LIB` : `QSYS.LIB/${Tools.sanitizeLibraryNames([library]).join(``)}.LIB`;
-    const filePath = `${object}.FILE`;
+    const filePath = object ? `/${object}.FILE` : '';
     const memberPath = member ? `/${member}.MBR` : '';
     const subPath = `${filePath}${memberPath}`;
 
-    const result = (iasp && iasp.length > 0 ? `/${iasp}` : ``) + `/${libraryPath}/${sanitise ? subPath : Tools.escapePath(subPath)}`;
+    const result = (iasp && iasp.length > 0 ? `/${iasp}` : ``) + `/${libraryPath}${subPath && sanitise ? subPath : Tools.escapePath(subPath)}`;
     return result;
   }
 
@@ -272,7 +275,7 @@ export namespace Tools {
   }
 
   export function parseQSysPath(path: string): QsysPath {
-    const parts = path.split('/');
+    const parts = path.split('/').filter(Boolean);
     if (parts.length > 3) {
       return {
         asp: parts[0],
@@ -389,4 +392,17 @@ export namespace Tools {
       }
     }
   }
+
+  /**
+   * Converts a timestamp from the attr command (in the form `Thu Dec 21 21:47:02 2023`) into a Date object
+   * @param timestamp an attr timestamp string
+   * @returns a Date object
+   */
+  export function parseAttrDate(timestamp:string){
+    const parts = /^([\w]{3}) ([\w]{3}) +([\d]+) ([\d]+:[\d]+:[\d]+) ([\d]+)$/.exec(timestamp);
+    if(parts){
+      return Date.parse(`${parts[3].padStart(2, "0")} ${parts[2]} ${parts[5]} ${parts[4]} GMT`);
+    }
+    return 0;
+  }
 }

src/extension.ts

@@ -89,7 +89,7 @@ export async function activate(context: ExtensionContext): Promise<CodeForIBMi>
         }
       }
     }),
-    workspace.registerFileSystemProvider(`streamfile`, new IFSFS(), {
+    workspace.registerFileSystemProvider(`streamfile`, new IFSFS(context), {
       isCaseSensitive: false
     }),
     languages.registerCompletionItemProvider({ language: 'json', pattern: "**/.vscode/actions.json" }, new LocalActionCompletionItemProvider(), "&")

src/filesystems/fileStatCache.ts

@@ -0,0 +1,26 @@
+import vscode from "vscode";
+
+export class FileStatCache {
+  private readonly cache: Map<string, vscode.FileStat | null> = new Map
+
+  set(uri: vscode.Uri | string, stat: vscode.FileStat | null) {
+    this.cache.set(toPath(uri), stat);
+  }
+
+  get(uri: vscode.Uri | string) {
+    return this.cache.get(toPath(uri));
+  }
+
+  clear(uri?: vscode.Uri | string) {
+    if (uri) {
+      this.cache.delete(toPath(uri));
+    }
+    else {
+      this.cache.clear();
+    }
+  }
+}
+
+function toPath(uri: vscode.Uri | string) {
+  return typeof uri === "string" ? uri : uri.path;
+}

src/filesystems/ifsFs.ts

@@ -1,11 +1,23 @@
-import vscode from "vscode";
-import { getFilePermission } from "./qsys/QSysFs";
+import vscode, { FileSystemError, FileType } from "vscode";
+import { Tools } from "../api/Tools";
 import { instance } from "../instantiate";
+import { FileStatCache } from "./fileStatCache";
+import { getFilePermission } from "./qsys/QSysFs";
 
 export class IFSFS implements vscode.FileSystemProvider {
   private emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
   onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]> = this.emitter.event;
 
+  private readonly statCache = new FileStatCache();
+
+  constructor(context: vscode.ExtensionContext) {
+    instance.onEvent("disconnected", () => { this.statCache.clear() });
+    context.subscriptions.push(
+      vscode.workspace.onDidCloseTextDocument((doc) => this.statCache.clear(doc.uri)),
+      vscode.commands.registerCommand("code-for-ibmi.clearIFSStats", (uri?: vscode.Uri | string) => this.statCache.clear(uri))
+    );
+  }
+
   watch(uri: vscode.Uri, options: { readonly recursive: boolean; readonly excludes: readonly string[]; }): vscode.Disposable {
     return { dispose: () => { } };
   }
@@ -18,7 +30,7 @@ export class IFSFS implements vscode.FileSystemProvider {
     }
     else {
       if (retrying) {
-        throw new Error("Not connected to IBM i");
+        throw new FileSystemError("Not connected to IBM i");
       }
       else {
         await vscode.commands.executeCommand(`code-for-ibmi.connectToPrevious`);
@@ -27,39 +39,110 @@ export class IFSFS implements vscode.FileSystemProvider {
     }
   }
 
-  stat(uri: vscode.Uri): vscode.FileStat {
-    return {
-      ctime: 0,
-      mtime: 0,
-      size: 0,
-      type: vscode.FileType.File,
-      permissions: getFilePermission(uri)
+  async stat(uri: vscode.Uri): Promise<vscode.FileStat> {
+    let currentStat = this.statCache.get(uri);
+    if (currentStat === undefined) {
+      const content = instance.getContent();
+      if (content) {
+        const path = uri.path;
+        if (await content.testStreamFile(path, "e")) {
+          const attributes = await content.getAttributes(path, "CREATE_TIME", "MODIFY_TIME", "DATA_SIZE", "OBJTYPE");
+          if (attributes) {
+            currentStat = {
+              ctime: Tools.parseAttrDate(String(attributes.CREATE_TIME)),
+              mtime: Tools.parseAttrDate(String(attributes.MODIFY_TIME)),
+              size: Number(attributes.DATA_SIZE),
+              type: String(attributes.OBJTYPE) === "*DIR" ? vscode.FileType.Directory : vscode.FileType.File,
+              permissions: getFilePermission(uri)
+            }
+          }
+        }
+        if (currentStat) {
+          this.statCache.set(uri, currentStat);
+        } else {
+          this.statCache.set(uri, null);
+          throw FileSystemError.FileNotFound(uri);
+        }
+      }
+      else {
+        currentStat = {
+          ctime: 0,
+          mtime: 0,
+          size: 0,
+          type: vscode.FileType.File,
+          permissions: getFilePermission(uri)
+        }
+      }
+    }
+    else if (currentStat === null) {
+      throw FileSystemError.FileNotFound(uri);
     }
+
+    return currentStat;
   }
 
   async writeFile(uri: vscode.Uri, content: Uint8Array, options: { readonly create: boolean; readonly overwrite: boolean; }) {
+    const path = uri.path;
+    const exists = this.statCache.get(path);
+    this.statCache.clear(path);
     const contentApi = instance.getContent();
     if (contentApi) {
-      contentApi.writeStreamfileRaw(uri.path, content);
+      if (!content.length) { //Coming from "Save as"        
+        await contentApi.createStreamFile(path);
+      }
+      else {
+        await contentApi.writeStreamfileRaw(path, content);
+      }
+      if (!exists) {
+        vscode.commands.executeCommand(`code-for-ibmi.refreshIFSBrowser`);
+      }
     }
     else {
-      throw new Error("Not connected to IBM i");
+      throw new FileSystemError("Not connected to IBM i");
     }
   }
 
+  copy(source: vscode.Uri, destination: vscode.Uri, options: { readonly overwrite: boolean; }): void | Thenable<void> {
+    this.statCache.clear(destination);
+  }
+
   rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: { readonly overwrite: boolean; }): void | Thenable<void> {
     console.log({ oldUri, newUri, options });
+    this.statCache.clear(oldUri);
+    this.statCache.clear(newUri);
   }
 
-  readDirectory(uri: vscode.Uri): [string, vscode.FileType][] | Thenable<[string, vscode.FileType][]> {
-    throw new Error(`readDirectory not implemented in IFSFS.`);
+  async readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]> {
+    const content = instance.getContent();
+    if (content) {
+      return (await content.getFileList(uri.path)).map(ifsFile => ([ifsFile.name, ifsFile.type === "directory" ? FileType.Directory : FileType.File]));
+    }
+    else {
+      throw new FileSystemError("Not connected to IBM i");
+    }
   }
 
-  createDirectory(uri: vscode.Uri): void | Thenable<void> {
-    throw new Error(`createDirectory not implemented in IFSFS.`);
+  async createDirectory(uri: vscode.Uri) {
+    const connection = instance.getConnection();
+    if (connection) {
+      const path = uri.path;
+      if (await connection.content.testStreamFile(path, "d")) {
+        throw FileSystemError.FileExists(uri);
+      }
+      else {
+        const result = await connection.sendCommand({ command: `mkdir -p ${path}` });
+        if (result.code === 0) {
+          this.statCache.clear(uri);
+        }
+        else {
+          throw FileSystemError.NoPermissions(result.stderr);
+        }
+      }
+    }
   }
 
   delete(uri: vscode.Uri, options: { readonly recursive: boolean; }): void | Thenable<void> {
-    throw new Error(`delete not implemented in IFSFS.`);
+    this.statCache.clear(uri);
+    throw new FileSystemError(`delete not implemented in IFSFS.`);
   }
 }