Refactor Explorer code (#1717)

Author: isc-bsaviano

package.json

@@ -331,11 +331,6 @@
           "when": "view == ObjectScriptProjectsExplorer",
           "group": "navigation"
         },
-        {
-          "command": "vscode-objectscript.explorer.project.openOtherServerNs",
-          "when": "view == ObjectScriptProjectsExplorer && vscode-objectscript.projectsExplorerRootCount > 0",
-          "group": "navigation"
-        },
         {
           "command": "vscode-objectscript.openISCDocument",
           "when": "view == workbench.explorer.fileView && vscode-objectscript.connectActive && workspaceFolderCount != 0",
@@ -433,6 +428,11 @@
           "when": "view == ObjectScriptProjectsExplorer && viewItem == projectsServerNsNode:extra",
           "group": "inline@10"
         },
+        {
+          "command": "vscode-objectscript.explorer.project.openOtherServerNs",
+          "when": "view == ObjectScriptProjectsExplorer && viewItem == projectsServerNsNode",
+          "group": "inline@10"
+        },
         {
           "command": "vscode-objectscript.intersystems-servermanager.webterminal",
           "when": "view == intersystems-community_servermanager && viewItem =~ /namespace$/ && (viewItem > 6 || !(viewItem =~ /^\\d+/))",
@@ -989,7 +989,7 @@
       {
         "category": "ObjectScript",
         "command": "vscode-objectscript.explorer.project.openOtherServerNs",
-        "title": "View Projects in Another Server Namespace",
+        "title": "View Projects in Another Namespace...",
         "icon": "$(add)"
       },
       {

src/api/index.ts

@@ -296,15 +296,8 @@ export class AtelierAPI {
   }
 
   public get connInfo(): string {
-    const { serverName, host, port, docker, dockerService } = this.config;
-    const ns = this.ns.toUpperCase();
-    return (
-      (docker
-        ? "docker" + (dockerService ? `:${dockerService}:${port}` : "")
-        : serverName
-          ? serverName
-          : `${host}:${port}`) + `[${ns}]`
-    );
+    const { port, docker, dockerService } = this.config;
+    return (docker ? "docker" + (dockerService ? `:${dockerService}:${port}` : "") : this.serverId) + `[${this.ns}]`;
   }
 
   /** Return the server's name in `intersystems.servers` if it exists, else its `host:port/pathPrefix` */

src/commands/addServerNamespaceToWorkspace.ts

@@ -17,7 +17,7 @@ import { isfsConfig, IsfsUriParam } from "../utils/FileProviderUtil";
  * @param message The prefix of the message to show when the server manager API can't be found.
  * @returns An object containing `serverName` and `namespace`, or `undefined`.
  */
-export async function pickServerAndNamespace(message?: string): Promise<{ serverName: string; namespace: string }> {
+async function pickServerAndNamespace(message?: string): Promise<{ serverName: string; namespace: string }> {
   if (!serverManagerApi) {
     vscode.window.showErrorMessage(
       `${

src/commands/compile.ts

@@ -434,10 +434,10 @@ export async function importFolder(uri: vscode.Uri, noCompile = false): Promise<
 }
 
 export async function compileExplorerItems(nodes: NodeBase[]): Promise<any> {
-  const { workspaceFolderUri, namespace } = nodes[0];
-  const conf = vscode.workspace.getConfiguration("objectscript", workspaceFolderUri);
-  const api = new AtelierAPI(workspaceFolderUri);
-  api.setNamespace(namespace);
+  const { wsFolder, namespace } = nodes[0];
+  const conf = vscode.workspace.getConfiguration("objectscript", wsFolder);
+  const api = new AtelierAPI(wsFolder.uri);
+  if (namespace) api.setNamespace(namespace);
   const docs = [];
   for (const node of nodes) {
     if (node instanceof PackageNode) {

src/commands/delete.ts

@@ -2,23 +2,21 @@ import * as vscode from "vscode";
 
 import { AtelierAPI } from "../api";
 import { FILESYSTEM_SCHEMA, explorerProvider } from "../extension";
-import { outputChannel, uriOfWorkspaceFolder } from "../utils";
+import { outputChannel } from "../utils";
 import { OtherStudioAction, fireOtherStudioAction } from "./studio";
 import { DocumentContentProvider } from "../providers/DocumentContentProvider";
 import { UserAction } from "../api/atelier";
 import { NodeBase, PackageNode, RootNode } from "../explorer/nodes";
 
-function deleteList(items: string[], workspaceFolder: string, namespace: string): Promise<any> {
+function deleteList(items: string[], wsFolder: vscode.WorkspaceFolder, namespace?: string): Promise<any> {
   if (!items || !items.length) {
-    vscode.window.showWarningMessage("Nothing to delete");
+    vscode.window.showWarningMessage("No documents to delete.", "Dismiss");
   }
-
-  const wsFolderUri = uriOfWorkspaceFolder(workspaceFolder);
-  const api = new AtelierAPI(workspaceFolder);
-  api.setNamespace(namespace);
+  const api = new AtelierAPI(wsFolder.uri);
+  if (namespace) api.setNamespace(namespace);
   return Promise.all(items.map((item) => api.deleteDoc(item))).then((files) => {
     files.forEach((file) => {
-      if (file.result.ext && wsFolderUri?.scheme == FILESYSTEM_SCHEMA) {
+      if (file.result.ext && wsFolder.uri.scheme == FILESYSTEM_SCHEMA) {
         // Only process source control output if we're in an isfs folder
         const uri = DocumentContentProvider.getUri(file.result.name);
         fireOtherStudioAction(OtherStudioAction.DeletedDocument, uri, <UserAction>file.result.ext);
@@ -29,7 +27,7 @@ function deleteList(items: string[], workspaceFolder: string, namespace: string)
 }
 
 export async function deleteExplorerItems(nodes: NodeBase[]): Promise<any> {
-  const { workspaceFolder, namespace } = nodes[0];
+  const { wsFolder, namespace } = nodes[0];
   const nodesPromiseList: Promise<NodeBase[]>[] = [];
   for (const node of nodes) {
     nodesPromiseList.push(node instanceof RootNode ? node.getChildren(node) : Promise.resolve([node]));
@@ -56,7 +54,7 @@ export async function deleteExplorerItems(nodes: NodeBase[]): Promise<any> {
           // Don't delete without confirmation
           return;
         }
-        deleteList(items, workspaceFolder, namespace);
+        deleteList(items, wsFolder, namespace);
         explorerProvider.refresh();
       }
     });

src/commands/export.ts

@@ -16,7 +16,6 @@ import {
   RateLimiter,
   replaceFile,
   stringifyError,
-  uriOfWorkspaceFolder,
   workspaceFolderOfUri,
 } from "../utils";
 import { pickDocuments } from "../utils/documentPicker";
@@ -127,24 +126,24 @@ async function exportFile(wsFolderUri: vscode.Uri, namespace: string, name: stri
   }
 }
 
-export async function exportList(files: string[], workspaceFolder: string, namespace: string): Promise<any> {
+export async function exportList(files: string[], wsFolder: vscode.WorkspaceFolder, namespace?: string): Promise<any> {
   if (!files || !files.length) {
     vscode.window.showWarningMessage("No documents to export.", "Dismiss");
     return;
   }
-  const wsFolderUri = uriOfWorkspaceFolder(workspaceFolder);
-  if (!workspaceFolder || !wsFolderUri) return;
-  if (!vscode.workspace.fs.isWritableFileSystem(wsFolderUri.scheme)) {
-    vscode.window.showErrorMessage(`Cannot export to read-only file system '${wsFolderUri.scheme}'.`, "Dismiss");
+  if (!wsFolder) return;
+  if (!vscode.workspace.fs.isWritableFileSystem(wsFolder.uri.scheme)) {
+    vscode.window.showErrorMessage(`Cannot export to read-only file system '${wsFolder.uri.scheme}'.`, "Dismiss");
     return;
   }
-  if (!new AtelierAPI(wsFolderUri).active) {
+  const api = new AtelierAPI(wsFolder.uri);
+  if (!api.active) {
     vscode.window.showErrorMessage("Exporting documents requires an active server connection.", "Dismiss");
     return;
   }
 
-  const { atelier, folder, addCategory, map } = config("export", workspaceFolder);
-  const root = wsFolderUri.fsPath + (folder.length ? path.sep + folder : "");
+  const { atelier, folder, addCategory, map } = config("export", wsFolder.name);
+  const root = wsFolder.uri.fsPath + (folder.length ? path.sep + folder : "");
   outputChannel.show(true);
   const rateLimiter = new RateLimiter(50);
   return vscode.window.withProgress(
@@ -157,7 +156,7 @@ export async function exportList(files: string[], workspaceFolder: string, names
       Promise.allSettled<void>(
         files.map((file) =>
           rateLimiter.call(() =>
-            exportFile(wsFolderUri, namespace, file, getFileName(root, file, atelier, addCategory, map))
+            exportFile(wsFolder.uri, namespace ?? api.ns, file, getFileName(root, file, atelier, addCategory, map))
           )
         )
       )
@@ -223,24 +222,21 @@ export async function exportAll(): Promise<any> {
     if (!files?.length) return;
     await exportList(
       files.map((file) => file.label),
-      wsFolder.name,
-      api.ns
+      wsFolder
     );
   } catch (error) {
     handleError(error, "Error executing 'Export Code from Server...' command.");
   }
 }
 
 export async function exportExplorerItems(nodes: NodeBase[]): Promise<any> {
-  const node = nodes[0];
-  const nodeNs = node.namespace.toUpperCase();
-  const origNamespace = config("conn", node.workspaceFolder).ns?.toUpperCase();
-  if (origNamespace?.toUpperCase() != node.namespace.toUpperCase()) {
+  const { wsFolder, namespace } = nodes[0];
+  if (namespace) {
     const answer = await vscode.window.showWarningMessage(
       `
-You are about to export from namespace ${nodeNs}.
+You are about to export from namespace ${namespace}.
 
-Future edits to the file(s) in your local workspace will be saved and compiled in the primary namespace of your workspace root, ${origNamespace}, not the namespace from which you originally exported.
+Future edits to the file(s) in your local workspace will be saved and compiled in the primary namespace of your workspace root, ${new AtelierAPI(wsFolder.uri).ns}, not the namespace from which you originally exported.
 
 Would you like to continue?`,
       {
@@ -252,9 +248,9 @@ Would you like to continue?`,
       return;
     }
   }
-  return Promise.all(nodes.map((node) => node.getItems4Export()))
+  return Promise.all(nodes.map((node) => node.getItemsForExport()))
     .then((items) => {
-      return exportList(items.flat(), node.workspaceFolder, nodeNs).then(() => explorerProvider.refresh());
+      return exportList(items.flat(), wsFolder, namespace).then(() => explorerProvider.refresh());
     })
     .catch((error) => {
       handleError(error, "Error exporting Explorer items.");
@@ -272,8 +268,7 @@ export async function exportCurrentFile(): Promise<any> {
     // Only export files opened from the explorer
     return;
   }
-  const api = new AtelierAPI(openDoc.uri);
-  return exportList([currentFile(openDoc).name], api.configName, api.config.ns);
+  return exportList([currentFile(openDoc).name], vscode.workspace.getWorkspaceFolder(openDoc.uri));
 }
 
 export async function exportDocumentsToXMLFile(): Promise<void> {

src/commands/project.ts

@@ -92,8 +92,8 @@ export async function pickProject(api: AtelierAPI, allowCreate = true): Promise<
 export async function createProject(node: NodeBase | undefined, api?: AtelierAPI): Promise<string | undefined> {
   if (api == undefined) {
     if (node instanceof NodeBase) {
-      api = new AtelierAPI(node.workspaceFolderUri);
-      api.setNamespace(node.namespace);
+      api = new AtelierAPI(node.wsFolder.uri);
+      if (node.namespace) api.setNamespace(node.namespace);
     } else {
       // Have the user pick a server connection
       const connUri = await getWsServerConnection();
@@ -160,8 +160,8 @@ export async function deleteProject(node: ProjectNode | undefined): Promise<any>
   let api: AtelierAPI;
   let project: string;
   if (node instanceof ProjectNode) {
-    api = new AtelierAPI(node.workspaceFolderUri);
-    api.setNamespace(node.namespace);
+    api = new AtelierAPI(node.wsFolder.uri);
+    if (node.namespace) api.setNamespace(node.namespace);
     project = node.label;
   } else {
     // Have the user pick a server connection
@@ -919,8 +919,7 @@ export async function exportProjectContents(): Promise<any> {
           [project]
         )
         .then((data) => data.result.content.map((e) => e.Name)),
-      wsFolder.name,
-      api.ns
+      wsFolder
     );
   } catch (error) {
     handleError(error, "Error executing 'Export Project Contents from Server...' command.");
@@ -1008,7 +1007,10 @@ export async function addIsfsFileToProject(project: string, fileName: string, ap
 
 export function addWorkspaceFolderForProject(node: ProjectNode): void {
   // Check if an isfs folder already exists for this project
-  const idx = isfsFolderForProject(node.label, new AtelierAPI(node.workspaceFolderUri));
+  const api = new AtelierAPI(node.wsFolder.uri);
+  if (node.namespace) api.setNamespace(node.namespace);
+  const serverName = api.config.serverName;
+  const idx = isfsFolderForProject(node.label, api);
   // If not, create one
   if (idx != -1) {
     vscode.window.showWarningMessage(`A workspace folder for this project already exists.`, "Dismiss");
@@ -1019,8 +1021,8 @@ export function addWorkspaceFolderForProject(node: ProjectNode): void {
     vscode.workspace.workspaceFolders ? vscode.workspace.workspaceFolders.length : 0,
     0,
     {
-      uri: vscode.Uri.parse(`isfs://${node.conn.serverName}:${node.namespace}/?project=${node.label}`),
-      name: `${node.label} - ${node.conn.serverName}:${node.namespace.toUpperCase()}`,
+      uri: vscode.Uri.parse(`isfs://${serverName}:${api.ns.toLowerCase()}/?project=${node.label}`),
+      name: `${node.label} - ${serverName}:${api.ns}`,
     }
   );
   // Switch to Explorer view so user sees the outcome
@@ -1036,8 +1038,8 @@ async function handleCommandArg(
   if (nodeOrUri instanceof NodeBase) {
     // Called from Projects Explorer
     node = nodeOrUri;
-    api = new AtelierAPI(node.workspaceFolderUri);
-    api.setNamespace(node.namespace);
+    api = new AtelierAPI(node.wsFolder.uri);
+    if (node.namespace) api.setNamespace(node.namespace);
     project = node.options.project;
   } else if (nodeOrUri instanceof vscode.Uri) {
     // Called from files explorer