Merge branch 'master'

Author: Tyler Deemer

src/api/index.ts

@@ -8,11 +8,10 @@ import {
   getResolvedConnectionSpec,
   config,
   extensionContext,
-  FILESYSTEM_SCHEMA,
-  FILESYSTEM_READONLY_SCHEMA,
   workspaceState,
   panel,
   checkConnection,
+  schemas,
 } from "../extension";
 import { currentWorkspaceFolder, outputConsole, outputChannel } from "../utils";
 
@@ -93,7 +92,7 @@ export class AtelierAPI {
     let namespace = "";
     if (wsOrFile) {
       if (wsOrFile instanceof vscode.Uri) {
-        if (wsOrFile.scheme === FILESYSTEM_SCHEMA || wsOrFile.scheme === FILESYSTEM_READONLY_SCHEMA) {
+        if (schemas.includes(wsOrFile.scheme)) {
           workspaceFolderName = wsOrFile.authority;
           const { query } = url.parse(decodeURIComponent(wsOrFile.toString()), true);
           if (query) {

src/commands/compile.ts

@@ -202,7 +202,9 @@ export async function importAndCompile(askFLags = false, document?: vscode.TextD
   if (!file) {
     return;
   }
-  if (!config("conn").active) {
+
+  // Do nothing if it is a local file and objectscript.conn.active is false
+  if (document.uri.scheme === "file" && !config("conn").active) {
     return;
   }
 

src/commands/studio.ts

@@ -286,7 +286,9 @@ class StudioActions {
             .then(() => resolve())
             .catch((err) => {
               console.log(err);
-              outputChannel.appendLine(`Studio Action "${action.label}" not supported`);
+              outputChannel.appendLine(
+                `Studio Action "${action.label}" not supported on ${this.api.config.host}:${this.api.config.port}[${this.api.config.ns}]`
+              );
               outputChannel.show();
               reject();
             });

src/extension.ts

@@ -238,7 +238,10 @@ export function checkConnection(clearCookies = false, uri?: vscode.Uri): void {
       /// Use xdebug's websocket, to catch when server disconnected
       connectionSocket = new WebSocket(api.xdebugUrl());
       connectionSocket.onopen = () => {
-        fireOtherStudioAction(OtherStudioAction.ConnectedToNewNamespace);
+        fireOtherStudioAction(
+          OtherStudioAction.ConnectedToNewNamespace,
+          typeof apiTarget === "string" ? undefined : apiTarget
+        );
         panel.text = `${connInfo} - Connected`;
       };
       connectionSocket.onclose = (event) => {

src/providers/FileSystemPovider/FileSystemProvider.ts

@@ -132,40 +132,51 @@ export class FileSystemProvider implements vscode.FileSystemProvider {
       return;
     }
     const api = new AtelierAPI(uri);
-    return this._lookupAsFile(uri)
-      .then(() => Promise.reject())
-      .catch((error) => {
-        if (error.code === "FileNotFound") {
-          return;
+    return this._lookupAsFile(uri).then(
+      () => {
+        // Weirdly, if the file exists on the server we don't actually write its content here.
+        // Instead we simply return as though we succeeded. The actual writing is done by our
+        // workspace.onDidSaveTextDocument handler.
+        return;
+      },
+      (error) => {
+        if (error.code !== "FileNotFound" || !options.create) {
+          return Promise.reject();
         }
-        return Promise.reject();
-      })
-      .then(() => {
+        // File doesn't exist on the server, and we are allowed to create it.
+        // Create content (typically a stub).
         const newContent = this.generateFileContent(fileName, content);
-        return api.putDoc(
-          fileName,
-          {
-            ...newContent,
-            mtime: Date.now(),
-          },
-          false
-        );
-      })
-      .catch((error) => {
-        if (error.error?.result?.status) {
-          throw vscode.FileSystemError.Unavailable(error.error.result.status);
-        }
-        throw vscode.FileSystemError.Unavailable(error.message);
-      })
-      .then((response) => {
-        if (response && response.result.ext && response.result.ext[0] && response.result.ext[1]) {
-          fireOtherStudioAction(OtherStudioAction.CreatedNewDocument, uri, response.result.ext[0]);
-          fireOtherStudioAction(OtherStudioAction.FirstTimeDocumentSave, uri, response.result.ext[1]);
-        }
-        this._lookupAsFile(uri).then((entry) => {
-          this._fireSoon({ type: vscode.FileChangeType.Changed, uri });
-        });
-      });
+
+        // Write it to the server
+        return api
+          .putDoc(
+            fileName,
+            {
+              ...newContent,
+              mtime: Date.now(),
+            },
+            false
+          )
+          .catch((error) => {
+            // Throw all failures
+            if (error.error?.result?.status) {
+              throw vscode.FileSystemError.Unavailable(error.error.result.status);
+            }
+            throw vscode.FileSystemError.Unavailable(error.message);
+          })
+          .then((response) => {
+            // New file has been written
+            if (response && response.result.ext && response.result.ext[0] && response.result.ext[1]) {
+              fireOtherStudioAction(OtherStudioAction.CreatedNewDocument, uri, response.result.ext[0]);
+              fireOtherStudioAction(OtherStudioAction.FirstTimeDocumentSave, uri, response.result.ext[1]);
+            }
+            // Sanity check that we find it there, then make client side update things
+            this._lookupAsFile(uri).then(() => {
+              this._fireSoon({ type: vscode.FileChangeType.Changed, uri });
+            });
+          });
+      }
+    );
   }
 
   public delete(uri: vscode.Uri, options: { recursive: boolean }): void | Thenable<void> {