Allow Save As and breadcrumb navigation

src/api/IBMi.ts

@@ -1,16 +1,15 @@
-import * as node_ssh from "node-ssh";
-import * as vscode from "vscode";
-import { ConnectionConfiguration } from "./Configuration";
-
 import { parse } from 'csv-parse/sync';
 import { existsSync } from "fs";
+import * as node_ssh from "node-ssh";
 import os from "os";
-import path from 'path';
+import path, { parse as parsePath } from 'path';
+import * as vscode from "vscode";
 import { ComponentId, ComponentManager } from "../components/component";
 import { CopyToImport } from "../components/copyToImport";
 import { instance } from "../instantiate";
 import { CommandData, CommandResult, ConnectionData, IBMiMember, RemoteCommand, SpecialAuthorities, WrapResult } from "../typings";
 import { CompileTools } from "./CompileTools";
+import { ConnectionConfiguration } from "./Configuration";
 import IBMiContent from "./IBMiContent";
 import { CachedServerSettings, GlobalStorage } from './Storage';
 import { Tools } from './Tools';
@@ -1180,20 +1179,21 @@ export default class IBMi {
       }
   }
 
-  parserMemberPath(string: string): MemberParts {
+  parserMemberPath(string: string, checkExtension?: boolean): MemberParts {
     const variant_chars_local = this.variantChars.local;
     const validQsysName = new RegExp(`^[A-Z0-9${variant_chars_local}][A-Z0-9_${variant_chars_local}.]{0,9}$`);
 
     // Remove leading slash
     const upperCasedString = this.upperCaseName(string);
     const path = upperCasedString.startsWith(`/`) ? upperCasedString.substring(1).split(`/`) : upperCasedString.split(`/`);
 
-    const basename = path[path.length - 1];
+    const parsedPath = parsePath(upperCasedString);
+    const name = parsedPath.name;
     const file = path[path.length - 2];
     const library = path[path.length - 3];
     const asp = path[path.length - 4];
 
-    if (!library || !file || !basename) {
+    if (!library || !file || !name) {
       throw new Error(`Invalid path: ${string}. Use format LIB/SPF/NAME.ext`);
     }
     if (asp && !validQsysName.test(asp)) {
@@ -1206,12 +1206,10 @@ export default class IBMi {
       throw new Error(`Invalid Source File name: ${file}`);
     }
 
-    //Having a blank extension is allowed but the . in the path is required
-    if (!basename.includes(`.`)) {
+    //Having a blank extension is allowed but the . in the path is required if checking the extension
+    if (checkExtension && !parsedPath.ext) {
       throw new Error(`Source Type extension is required.`);
     }
-    const name = basename.substring(0, basename.lastIndexOf(`.`));
-    const extension = basename.substring(basename.lastIndexOf(`.`) + 1).trim();
 
     if (!validQsysName.test(name)) {
       throw new Error(`Invalid Source Member name: ${name}`);
@@ -1221,6 +1219,7 @@ export default class IBMi {
     // the existing RegExp because result.extension is everything after
     // the final period (so we know it won't contain a period).
     // But, a blank extension is valid.
+    const extension = parsedPath.ext.substring(1);
     if (extension && !validQsysName.test(extension)) {
       throw new Error(`Invalid Source Member Extension: ${extension}`);
     }
@@ -1229,7 +1228,7 @@ export default class IBMi {
       library,
       file,
       extension,
-      basename,
+      basename: parsedPath.base,
       name,
       asp
     };

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 {
@@ -828,7 +827,7 @@ export default class IBMiContent {
 
           // This can error if the path format is wrong for some reason.
           // Not that this would ever happen, but better to be safe than sorry
-          return this.ibmi.parserMemberPath(simplePath);
+          return this.ibmi.parserMemberPath(simplePath, true);
         } catch (e) {
           console.log(e);
         }
@@ -907,7 +906,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;
   }
 
@@ -952,8 +951,9 @@ export default class IBMiContent {
     return cl;
   }
 
-  async getAttributes(path: string | (QsysPath & { member?: string }), ...operands: AttrOperands[]) {
-    const target = (path = typeof path === 'string' ? Tools.escapePath(path) : Tools.qualifyPath(path.library, path.name, path.member, path.asp));
+  async getAttributes(path: string | (QsysPath & { member?: string }), ...operands: AttrOperands[]) {    
+    const target = (path = typeof path === 'string' ? Tools.escapePath(path) : this.ibmi.sysNameInAmerican(Tools.qualifyPath(path.library, path.name, path.member, path.asp)));
+
     const result = await this.ibmi.sendCommand({ command: `${this.ibmi.remoteFeatures.attr} -p ${target} ${operands.join(" ")}` });
     if (result.code === 0) {
       return result.stdout
@@ -1022,4 +1022,17 @@ export default class IBMiContent {
     tooltip.supportHtml = true;
     return tooltip;
   }
+
+  /**
+   * 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,7 +177,7 @@ export namespace Tools {
    */
   export function qualifyPath(library: string, object: string, member?: string, iasp?: string, noEscape?: 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}`;
 
@@ -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],
@@ -426,4 +429,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/filesystems/ifsFs.ts

@@ -1,8 +1,10 @@
-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 { getFilePermission } from "./qsys/QSysFs";
 
 export class IFSFS implements vscode.FileSystemProvider {
+  private readonly savedAsFiles: Set<string> = new Set;
   private emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
   onDidChangeFile: vscode.Event<vscode.FileChangeEvent[]> = this.emitter.event;
 
@@ -18,7 +20,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 +29,90 @@ 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> {
+    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) {
+          const type = String(attributes.OBJTYPE) === "*DIR" ? vscode.FileType.Directory : vscode.FileType.File;
+          return {
+            ctime: Tools.parseAttrDate(String(attributes.CREATE_TIME)),
+            mtime: Tools.parseAttrDate(String(attributes.MODIFY_TIME)),
+            size: Number(attributes.DATA_SIZE),
+            type,
+            permissions: !this.savedAsFiles.has(path) && type !== FileType.Directory ? getFilePermission(uri) : undefined
+          }
+        }
+      }
+      throw FileSystemError.FileNotFound(uri);
+    }
+    else {
+      return {
+        ctime: 0,
+        mtime: 0,
+        size: 0,
+        type: vscode.FileType.File,
+        permissions: getFilePermission(uri)
+      }
     }
   }
 
   async writeFile(uri: vscode.Uri, content: Uint8Array, options: { readonly create: boolean; readonly overwrite: boolean; }) {
+    const path = uri.path;
     const contentApi = instance.getContent();
     if (contentApi) {
-      contentApi.writeStreamfileRaw(uri.path, content);
+      if (!content.length) { //Coming from "Save as"    
+        this.savedAsFiles.add(path);
+        await contentApi.createStreamFile(path);
+        vscode.commands.executeCommand(`code-for-ibmi.refreshIFSBrowser`);
+      }
+      else {
+        this.savedAsFiles.delete(path);
+        await contentApi.writeStreamfileRaw(path, content);
+      }
     }
     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> {
+    //not used at the moment
+  }
+
   rename(oldUri: vscode.Uri, newUri: vscode.Uri, options: { readonly overwrite: boolean; }): void | Thenable<void> {
-    console.log({ oldUri, newUri, options });
+    //not used at the moment
   }
 
-  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) {
+          throw FileSystemError.NoPermissions(result.stderr);
+        }
+      }
+    }
   }
 
   delete(uri: vscode.Uri, options: { readonly recursive: boolean; }): void | Thenable<void> {
-    throw new Error(`delete not implemented in IFSFS.`);
+    throw new FileSystemError(`delete not implemented in IFSFS.`);
   }
 }