#964 Prompt move when opening invalid sketch outside from IDE2

arduino-ide-extension/package.json

@@ -45,6 +45,7 @@
     "@types/deepmerge": "^2.2.0",
     "@types/glob": "^7.2.0",
     "@types/google-protobuf": "^3.7.2",
+    "@types/is-valid-path": "^0.1.0",
     "@types/js-yaml": "^3.12.2",
     "@types/keytar": "^4.4.0",
     "@types/lodash.debounce": "^4.0.6",

arduino-ide-extension/src/browser/contributions/contribution.ts

@@ -12,7 +12,6 @@ import { MaybePromise } from '@theia/core/lib/common/types';
 import { LabelProvider } from '@theia/core/lib/browser/label-provider';
 import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
 import { MessageService } from '@theia/core/lib/common/message-service';
-import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
 import { open, OpenerService } from '@theia/core/lib/browser/opener-service';
 
 import {
@@ -61,6 +60,7 @@ import { BoardsServiceProvider } from '../boards/boards-service-provider';
 import { BoardsDataStore } from '../boards/boards-data-store';
 import { NotificationManager } from '../theia/messages/notifications-manager';
 import { MessageType } from '@theia/core/lib/common/message-service-protocol';
+import { WorkspaceService } from '../theia/workspace/workspace-service';
 
 export {
   Command,

arduino-ide-extension/src/browser/contributions/open-sketch-files.ts

@@ -1,18 +1,28 @@
 import { nls } from '@theia/core/lib/common/nls';
-import { injectable } from '@theia/core/shared/inversify';
+import { inject, injectable } from '@theia/core/shared/inversify';
 import type { EditorOpenerOptions } from '@theia/editor/lib/browser/editor-manager';
 import { Later } from '../../common/nls';
-import { SketchesError } from '../../common/protocol';
+import { Sketch, SketchesError } from '../../common/protocol';
 import {
   Command,
   CommandRegistry,
   SketchContribution,
   URI,
 } from './contribution';
 import { SaveAsSketch } from './save-as-sketch';
+import { promptMoveSketch } from './open-sketch';
+import { ApplicationError } from '@theia/core/lib/common/application-error';
+import { Deferred, wait } from '@theia/core/lib/common/promise-util';
+import { EditorWidget } from '@theia/editor/lib/browser/editor-widget';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
+import { ContextKeyService as VSCodeContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/browser/contextKeyService';
 
 @injectable()
 export class OpenSketchFiles extends SketchContribution {
+  @inject(VSCodeContextKeyService)
+  private readonly contextKeyService: VSCodeContextKeyService;
+
   override registerCommands(registry: CommandRegistry): void {
     registry.registerCommand(OpenSketchFiles.Commands.OPEN_SKETCH_FILES, {
       execute: (uri: URI) => this.openSketchFiles(uri),
@@ -55,9 +65,25 @@ export class OpenSketchFiles extends SketchContribution {
           }
         });
       }
+      const { workspaceError } = this.workspaceService;
+      // This happens when the IDE2 has been started (from either a terminal or clicking on an `ino` file) with a /path/to/invalid/sketch. (#964)
+      if (SketchesError.InvalidName.is(workspaceError)) {
+        await this.promptMove(workspaceError);
+      }
     } catch (err) {
+      // This happens when the user gracefully closed IDE2, all went well
+      // but the main sketch file was renamed outside of IDE2 and when the user restarts the IDE2
+      // the workspace path still exists, but the sketch path is not valid anymore. (#964)
+      if (SketchesError.InvalidName.is(err)) {
+        const movedSketch = await this.promptMove(err);
+        if (!movedSketch) {
+          // If user did not accept the move, or move was not possible, force reload with a fallback.
+          return this.openFallbackSketch();
+        }
+      }
+
       if (SketchesError.NotFound.is(err)) {
-        this.openFallbackSketch();
+        return this.openFallbackSketch();
       } else {
         console.error(err);
         const message =
@@ -71,6 +97,31 @@ export class OpenSketchFiles extends SketchContribution {
     }
   }
 
+  private async promptMove(
+    err: ApplicationError<
+      number,
+      {
+        invalidMainSketchUri: string;
+      }
+    >
+  ): Promise<Sketch | undefined> {
+    const { invalidMainSketchUri } = err.data;
+    requestAnimationFrame(() => this.messageService.error(err.message));
+    await wait(10); // let IDE2 toast the error message.
+    const movedSketch = await promptMoveSketch(invalidMainSketchUri, {
+      fileService: this.fileService,
+      sketchService: this.sketchService,
+      labelProvider: this.labelProvider,
+    });
+    if (movedSketch) {
+      this.workspaceService.open(new URI(movedSketch.uri), {
+        preserveWindow: true,
+      });
+      return movedSketch;
+    }
+    return undefined;
+  }
+
   private async openFallbackSketch(): Promise<void> {
     const sketch = await this.sketchService.createNewSketch();
     this.workspaceService.open(new URI(sketch.uri), { preserveWindow: true });
@@ -84,15 +135,69 @@ export class OpenSketchFiles extends SketchContribution {
     const widget = this.editorManager.all.find(
       (widget) => widget.editor.uri.toString() === uri
     );
+    const disposables = new DisposableCollection();
     if (!widget || forceOpen) {
-      return this.editorManager.open(
+      const deferred = new Deferred<EditorWidget>();
+      disposables.push(
+        this.editorManager.onCreated((editor) => {
+          if (editor.editor.uri.toString() === uri) {
+            if (editor.isVisible) {
+              disposables.dispose();
+              deferred.resolve(editor);
+            } else {
+              // In Theia, the promise resolves after opening the editor, but the editor is neither attached to the DOM, nor visible.
+              // This is a hack to first get an event from monaco after the widget update request, then IDE2 waits for the next monaco context key event.
+              // Here, the monaco context key event is not used, but this is the first event after the editor is visible in the UI.
+              disposables.push(
+                (editor.editor as MonacoEditor).onDidResize((dimension) => {
+                  if (dimension) {
+                    const isKeyOwner = (
+                      arg: unknown
+                    ): arg is { key: string } => {
+                      if (typeof arg === 'object') {
+                        const object = arg as Record<string, unknown>;
+                        return typeof object['key'] === 'string';
+                      }
+                      return false;
+                    };
+                    disposables.push(
+                      this.contextKeyService.onDidChangeContext((e) => {
+                        // `commentIsEmpty` is the first context key change event received from monaco after the editor is for real visible in the UI.
+                        if (isKeyOwner(e) && e.key === 'commentIsEmpty') {
+                          deferred.resolve(editor);
+                          disposables.dispose();
+                        }
+                      })
+                    );
+                  }
+                })
+              );
+            }
+          }
+        })
+      );
+      this.editorManager.open(
         new URI(uri),
         options ?? {
           mode: 'reveal',
           preview: false,
           counter: 0,
         }
       );
+      const timeout = 5_000; // number of ms IDE2 waits for the editor to show up in the UI
+      const result = await Promise.race([
+        deferred.promise,
+        wait(timeout).then(() => {
+          disposables.dispose();
+          return 'timeout';
+        }),
+      ]);
+      if (result === 'timeout') {
+        console.warn(
+          `Timeout after ${timeout} millis. The editor has not shown up in time. URI: ${uri}`
+        );
+      }
+      return result;
     }
   }
 }

arduino-ide-extension/src/browser/contributions/open-sketch.ts

@@ -1,7 +1,13 @@
 import * as remote from '@theia/core/electron-shared/@electron/remote';
 import { nls } from '@theia/core/lib/common/nls';
 import { injectable } from '@theia/core/shared/inversify';
-import { SketchesError, SketchRef } from '../../common/protocol';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { LabelProvider } from '@theia/core/lib/browser/label-provider';
+import {
+  SketchesError,
+  SketchesService,
+  SketchRef,
+} from '../../common/protocol';
 import { ArduinoMenus } from '../menu/arduino-menus';
 import {
   Command,
@@ -108,45 +114,11 @@ export class OpenSketch extends SketchContribution {
       return sketch;
     }
     if (Sketch.isSketchFile(sketchFileUri)) {
-      const name = new URI(sketchFileUri).path.name;
-      const nameWithExt = this.labelProvider.getName(new URI(sketchFileUri));
-      const { response } = await remote.dialog.showMessageBox({
-        title: nls.localize('arduino/sketch/moving', 'Moving'),
-        type: 'question',
-        buttons: [
-          nls.localize('vscode/issueMainService/cancel', 'Cancel'),
-          nls.localize('vscode/issueMainService/ok', 'OK'),
-        ],
-        message: nls.localize(
-          'arduino/sketch/movingMsg',
-          'The file "{0}" needs to be inside a sketch folder named "{1}".\nCreate this folder, move the file, and continue?',
-          nameWithExt,
-          name
-        ),
+      return promptMoveSketch(sketchFileUri, {
+        fileService: this.fileService,
+        sketchService: this.sketchService,
+        labelProvider: this.labelProvider,
       });
-      if (response === 1) {
-        // OK
-        const newSketchUri = new URI(sketchFileUri).parent.resolve(name);
-        const exists = await this.fileService.exists(newSketchUri);
-        if (exists) {
-          await remote.dialog.showMessageBox({
-            type: 'error',
-            title: nls.localize('vscode/dialog/dialogErrorMessage', 'Error'),
-            message: nls.localize(
-              'arduino/sketch/cantOpen',
-              'A folder named "{0}" already exists. Can\'t open sketch.',
-              name
-            ),
-          });
-          return undefined;
-        }
-        await this.fileService.createFolder(newSketchUri);
-        await this.fileService.move(
-          new URI(sketchFileUri),
-          new URI(newSketchUri.resolve(nameWithExt).toString())
-        );
-        return this.sketchService.getSketchFolder(newSketchUri.toString());
-      }
     }
   }
 }
@@ -158,3 +130,55 @@ export namespace OpenSketch {
     };
   }
 }
+
+export async function promptMoveSketch(
+  sketchFileUri: string | URI,
+  options: {
+    fileService: FileService;
+    sketchService: SketchesService;
+    labelProvider: LabelProvider;
+  }
+): Promise<Sketch | undefined> {
+  const { fileService, sketchService, labelProvider } = options;
+  const uri =
+    sketchFileUri instanceof URI ? sketchFileUri : new URI(sketchFileUri);
+  const name = uri.path.name;
+  const nameWithExt = labelProvider.getName(uri);
+  const { response } = await remote.dialog.showMessageBox({
+    title: nls.localize('arduino/sketch/moving', 'Moving'),
+    type: 'question',
+    buttons: [
+      nls.localize('vscode/issueMainService/cancel', 'Cancel'),
+      nls.localize('vscode/issueMainService/ok', 'OK'),
+    ],
+    message: nls.localize(
+      'arduino/sketch/movingMsg',
+      'The file "{0}" needs to be inside a sketch folder named "{1}".\nCreate this folder, move the file, and continue?',
+      nameWithExt,
+      name
+    ),
+  });
+  if (response === 1) {
+    // OK
+    const newSketchUri = uri.parent.resolve(name);
+    const exists = await fileService.exists(newSketchUri);
+    if (exists) {
+      await remote.dialog.showMessageBox({
+        type: 'error',
+        title: nls.localize('vscode/dialog/dialogErrorMessage', 'Error'),
+        message: nls.localize(
+          'arduino/sketch/cantOpen',
+          'A folder named "{0}" already exists. Can\'t open sketch.',
+          name
+        ),
+      });
+      return undefined;
+    }
+    await fileService.createFolder(newSketchUri);
+    await fileService.move(
+      uri,
+      new URI(newSketchUri.resolve(nameWithExt).toString())
+    );
+    return sketchService.getSketchFolder(newSketchUri.toString());
+  }
+}

arduino-ide-extension/src/browser/theia/workspace/workspace-service.ts

@@ -16,6 +16,7 @@ import {
 import {
   SketchesService,
   Sketch,
+  SketchesError,
 } from '../../../common/protocol/sketches-service';
 import { FileStat } from '@theia/filesystem/lib/common/files';
 import {
@@ -38,6 +39,7 @@ export class WorkspaceService extends TheiaWorkspaceService {
   private readonly providers: ContributionProvider<StartupTaskProvider>;
 
   private version?: string;
+  private _workspaceError: Error | undefined;
 
   async onStart(application: FrontendApplication): Promise<void> {
     const info = await this.applicationServer.getApplicationInfo();
@@ -51,6 +53,10 @@ export class WorkspaceService extends TheiaWorkspaceService {
     this.onCurrentWidgetChange({ newValue, oldValue: null });
   }
 
+  get workspaceError(): Error | undefined {
+    return this._workspaceError;
+  }
+
   protected override async toFileStat(
     uri: string | URI | undefined
   ): Promise<FileStat | undefined> {
@@ -59,6 +65,31 @@ export class WorkspaceService extends TheiaWorkspaceService {
       const newSketchUri = await this.sketchService.createNewSketch();
       return this.toFileStat(newSketchUri.uri);
     }
+    // When opening a file instead of a directory, IDE2 (and Theia) expects a workspace JSON file.
+    // Nothing will work if the workspace file is invalid. Users tend to start (see #964) IDE2 from the `.ino` files,
+    // so here, IDE2 tries to load the sketch via the CLI from the main sketch file URI.
+    // If loading the sketch is OK, IDE2 starts and uses the sketch folder as the workspace root instead of the sketch file.
+    // If loading fails due to invalid name error, IDE2 loads a temp sketch and preserves the startup error, and offers the sketch move to the user later.
+    // If loading the sketch fails, create a fallback sketch and open the new temp sketch folder as the workspace root.
+    if (stat.isFile && stat.resource.path.ext === '.ino') {
+      try {
+        const sketch = await this.sketchService.loadSketch(
+          stat.resource.toString()
+        );
+        return this.toFileStat(sketch.uri);
+      } catch (err) {
+        if (SketchesError.InvalidName.is(err)) {
+          this._workspaceError = err;
+          const newSketchUri = await this.sketchService.createNewSketch();
+          return this.toFileStat(newSketchUri.uri);
+        } else if (SketchesError.NotFound.is(err)) {
+          this._workspaceError = err;
+          const newSketchUri = await this.sketchService.createNewSketch();
+          return this.toFileStat(newSketchUri.uri);
+        }
+        throw err;
+      }
+    }
     return stat;
   }
 

arduino-ide-extension/src/common/protocol/sketches-service.ts

@@ -4,6 +4,7 @@ import URI from '@theia/core/lib/common/uri';
 export namespace SketchesError {
   export const Codes = {
     NotFound: 5001,
+    InvalidName: 5002,
   };
   export const NotFound = ApplicationError.declare(
     Codes.NotFound,
@@ -14,6 +15,15 @@ export namespace SketchesError {
       };
     }
   );
+  export const InvalidName = ApplicationError.declare(
+    Codes.InvalidName,
+    (message: string, invalidMainSketchUri: string) => {
+      return {
+        message,
+        data: { invalidMainSketchUri },
+      };
+    }
+  );
 }
 
 export const SketchesServicePath = '/services/sketches-service';