s

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

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

@@ -21,17 +21,16 @@ import {
   MenuModelRegistry,
 } from './contribution';
 import { NotificationCenter } from '../notification-center';
-import { Board, SketchRef, SketchContainer } from '../../common/protocol';
+import {
+  Board,
+  SketchRef,
+  SketchContainer,
+  SketchesError,
+} from '../../common/protocol';
 import { nls } from '@theia/core/lib/common';
 
 @injectable()
 export abstract class Examples extends SketchContribution {
-  @inject(CommandRegistry)
-  protected readonly commandRegistry: CommandRegistry;
-
-  @inject(MenuModelRegistry)
-  protected readonly menuRegistry: MenuModelRegistry;
-
   @inject(MainMenuManager)
   protected readonly menuManager: MainMenuManager;
 
@@ -41,6 +40,12 @@ export abstract class Examples extends SketchContribution {
   @inject(BoardsServiceProvider)
   protected readonly boardsServiceClient: BoardsServiceProvider;
 
+  @inject(CommandRegistry)
+  private readonly commandRegistry: CommandRegistry;
+
+  @inject(MenuModelRegistry)
+  private readonly menuRegistry: MenuModelRegistry;
+
   protected readonly toDispose = new DisposableCollection();
 
   protected override init(): void {
@@ -50,10 +55,13 @@ export abstract class Examples extends SketchContribution {
     );
   }
 
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-vars
   protected handleBoardChanged(board: Board | undefined): void {
     // NOOP
   }
 
+  protected abstract update(board?: Board | undefined): void;
+
   override registerMenus(registry: MenuModelRegistry): void {
     try {
       // This is a hack the ensures the desired menu ordering! We cannot use https://github.com/eclipse-theia/theia/pull/8377 due to ATL-222.
@@ -149,11 +157,19 @@ export abstract class Examples extends SketchContribution {
   protected createHandler(uri: string): CommandHandler {
     return {
       execute: async () => {
-        const sketch = await this.sketchService.cloneExample(uri);
-        return this.commandService.executeCommand(
-          OpenSketch.Commands.OPEN_SKETCH.id,
-          sketch
-        );
+        try {
+          const sketch = await this.sketchService.cloneExample(uri);
+          return this.commandService.executeCommand(
+            OpenSketch.Commands.OPEN_SKETCH.id,
+            sketch
+          );
+        } catch (err) {
+          if (SketchesError.NotFound.is(err)) {
+            this.update();
+          } else {
+            throw err;
+          }
+        }
       },
     };
   }
@@ -162,10 +178,10 @@ export abstract class Examples extends SketchContribution {
 @injectable()
 export class BuiltInExamples extends Examples {
   override async onReady(): Promise<void> {
-    this.register(); // no `await`
+    this.update(); // no `await`
   }
 
-  protected async register(): Promise<void> {
+  protected override async update(): Promise<void> {
     let sketchContainers: SketchContainer[] | undefined;
     try {
       sketchContainers = await this.examplesService.builtIns();
@@ -197,24 +213,24 @@ export class BuiltInExamples extends Examples {
 @injectable()
 export class LibraryExamples extends Examples {
   @inject(NotificationCenter)
-  protected readonly notificationCenter: NotificationCenter;
+  private readonly notificationCenter: NotificationCenter;
 
-  protected readonly queue = new PQueue({ autoStart: true, concurrency: 1 });
+  private readonly queue = new PQueue({ autoStart: true, concurrency: 1 });
 
   override onStart(): void {
-    this.notificationCenter.onLibraryDidInstall(() => this.register());
-    this.notificationCenter.onLibraryDidUninstall(() => this.register());
+    this.notificationCenter.onLibraryDidInstall(() => this.update());
+    this.notificationCenter.onLibraryDidUninstall(() => this.update());
   }
 
   override async onReady(): Promise<void> {
-    this.register(); // no `await`
+    this.update(); // no `await`
   }
 
   protected override handleBoardChanged(board: Board | undefined): void {
-    this.register(board);
+    this.update(board);
   }
 
-  protected async register(
+  protected override async update(
     board: Board | undefined = this.boardsServiceClient.boardsConfig
       .selectedBoard
   ): Promise<void> {

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

@@ -15,6 +15,7 @@ import { MainMenuManager } from '../../common/main-menu-manager';
 import { OpenSketch } from './open-sketch';
 import { NotificationCenter } from '../notification-center';
 import { nls } from '@theia/core/lib/common';
+import { SketchesError } from '../../common/protocol';
 
 @injectable()
 export class OpenRecentSketch extends SketchContribution {
@@ -42,6 +43,10 @@ export class OpenRecentSketch extends SketchContribution {
   }
 
   override async onReady(): Promise<void> {
+    this.update();
+  }
+
+  private update(): void {
     this.sketchService
       .recentlyOpenedSketches()
       .then((sketches) => this.refreshMenu(sketches));
@@ -70,11 +75,20 @@ export class OpenRecentSketch extends SketchContribution {
       }
       const command = { id: `arduino-open-recent--${uri}` };
       const handler = {
-        execute: () =>
-          this.commandRegistry.executeCommand(
-            OpenSketch.Commands.OPEN_SKETCH.id,
-            sketch
-          ),
+        execute: async () => {
+          try {
+            await this.commandRegistry.executeCommand(
+              OpenSketch.Commands.OPEN_SKETCH.id,
+              sketch
+            );
+          } catch (err) {
+            if (SketchesError.NotFound.is(err)) {
+              this.update();
+            } else {
+              throw err;
+            }
+          }
+        },
       };
       this.commandRegistry.registerCommand(command, handler);
       this.menuRegistry.registerMenuAction(

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

@@ -1,6 +1,5 @@
 import { inject, injectable } from '@theia/core/shared/inversify';
 import * as remote from '@theia/core/electron-shared/@electron/remote';
-import { MaybePromise } from '@theia/core/lib/common/types';
 import { Widget, ContextMenuRenderer } from '@theia/core/lib/browser';
 import {
   Disposable,
@@ -20,32 +19,81 @@ import {
 import { ExamplesService } from '../../common/protocol/examples-service';
 import { BuiltInExamples } from './examples';
 import { Sketchbook } from './sketchbook';
-import { SketchContainer } from '../../common/protocol';
-import { nls } from '@theia/core/lib/common';
+import {
+  SketchContainer,
+  SketchesError,
+  SketchRef,
+} from '../../common/protocol';
+import { nls } from '@theia/core/lib/common/nls';
+
+export type SketchLocation = string | URI | SketchRef | Sketch;
+export namespace SketchLocation {
+  export function toUri(location: SketchLocation): URI {
+    if (typeof location === 'string') {
+      return new URI(location);
+    } else if (SketchRef.is(location)) {
+      return toUri(location.uri);
+    } else if (Sketch.is(location)) {
+      return toUri(location.uri);
+    } else {
+      return location;
+    }
+  }
+}
+export interface OpenSketchParams {
+  readonly toOpen: SketchLocation;
+  /**
+   * If `true`, the open sketch command will try to open the sketch in a new workspace even if the sketch is invalid or missing.
+   * If an invalid sketch is opened in a Theia workspace, a new temporary sketch will be created on the fly, and the
+   * workspace will fall back to the new temporary sketch location. It's `false` by default.
+   */
+  readonly forceOpen?: boolean;
+}
+export namespace OpenSketchParams {
+  export function is(arg: unknown): arg is OpenSketchParams {
+    if (typeof arg === 'object') {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return 'toOpen' in (arg as any);
+    }
+    return false;
+  }
+}
 
 @injectable()
 export class OpenSketch extends SketchContribution {
   @inject(MenuModelRegistry)
-  protected readonly menuRegistry: MenuModelRegistry;
+  private readonly menuRegistry: MenuModelRegistry;
 
   @inject(ContextMenuRenderer)
-  protected readonly contextMenuRenderer: ContextMenuRenderer;
+  private readonly contextMenuRenderer: ContextMenuRenderer;
 
   @inject(BuiltInExamples)
-  protected readonly builtInExamples: BuiltInExamples;
+  private readonly builtInExamples: BuiltInExamples;
 
   @inject(ExamplesService)
-  protected readonly examplesService: ExamplesService;
+  private readonly examplesService: ExamplesService;
 
   @inject(Sketchbook)
-  protected readonly sketchbook: Sketchbook;
+  private readonly sketchbook: Sketchbook;
 
-  protected readonly toDispose = new DisposableCollection();
+  private readonly toDispose = new DisposableCollection();
 
   override registerCommands(registry: CommandRegistry): void {
     registry.registerCommand(OpenSketch.Commands.OPEN_SKETCH, {
-      execute: (arg) =>
-        Sketch.is(arg) ? this.openSketch(arg) : this.openSketch(),
+      execute: async (arg) => {
+        let toOpen: string | URI | SketchRef | Sketch | undefined = undefined;
+        if (!OpenSketchParams.is(arg)) {
+          toOpen = await this.selectSketch();
+        } else {
+          toOpen = arg.toOpen;
+        }
+        if (toOpen) {
+          return this.openSketch(
+            toOpen,
+            OpenSketchParams.is(arg) ? arg.forceOpen : false
+          );
+        }
+      },
     });
     registry.registerCommand(OpenSketch.Commands.OPEN_SKETCH__TOOLBAR, {
       isVisible: (widget) =>
@@ -55,7 +103,7 @@ export class OpenSketch extends SketchContribution {
           exclude: ['**/hardware/**'],
         });
         if (SketchContainer.isEmpty(container)) {
-          this.openSketch();
+          this.selectSketch().then((sketch) => this.openSketch(sketch));
         } else {
           this.toDispose.dispose();
           if (!(target instanceof HTMLElement)) {
@@ -130,16 +178,28 @@ export class OpenSketch extends SketchContribution {
     });
   }
 
-  async openSketch(
-    toOpen: MaybePromise<Sketch | undefined> = this.selectSketch()
+  private async openSketch(
+    toOpen: SketchLocation | undefined,
+    forceOpen?: boolean
   ): Promise<void> {
-    const sketch = await toOpen;
-    if (sketch) {
-      this.workspaceService.open(new URI(sketch.uri));
+    if (!toOpen) {
+      return;
+    }
+    const uri = SketchLocation.toUri(toOpen);
+    if (!forceOpen) {
+      try {
+        await this.sketchService.loadSketch(uri.toString());
+      } catch (err) {
+        if (SketchesError.NotFound.is(err)) {
+          this.messageService.error(err.message);
+        }
+        throw err;
+      }
     }
+    this.workspaceService.open(uri);
   }
 
-  protected async selectSketch(): Promise<Sketch | undefined> {
+  private async selectSketch(): Promise<Sketch | undefined> {
     const config = await this.configService.getConfiguration();
     const defaultPath = await this.fileService.fsPath(
       new URI(config.sketchDirUri)

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

@@ -1,32 +1,14 @@
-import { inject, injectable } from '@theia/core/shared/inversify';
+import { injectable } from '@theia/core/shared/inversify';
 import { CommandHandler } from '@theia/core/lib/common/command';
-import { CommandRegistry, MenuModelRegistry } from './contribution';
+import { MenuModelRegistry } from './contribution';
 import { ArduinoMenus } from '../menu/arduino-menus';
-import { MainMenuManager } from '../../common/main-menu-manager';
-import { NotificationCenter } from '../notification-center';
 import { Examples } from './examples';
-import {
-  SketchContainer,
-  SketchesError,
-  SketchRef,
-} from '../../common/protocol';
+import { SketchContainer, SketchesError } from '../../common/protocol';
 import { OpenSketch } from './open-sketch';
-import { nls } from '@theia/core/lib/common';
+import { nls } from '@theia/core/lib/common/nls';
 
 @injectable()
 export class Sketchbook extends Examples {
-  @inject(CommandRegistry)
-  protected override readonly commandRegistry: CommandRegistry;
-
-  @inject(MenuModelRegistry)
-  protected override readonly menuRegistry: MenuModelRegistry;
-
-  @inject(MainMenuManager)
-  protected readonly mainMenuManager: MainMenuManager;
-
-  @inject(NotificationCenter)
-  protected readonly notificationCenter: NotificationCenter;
-
   override onStart(): void {
     this.sketchServiceClient.onSketchbookDidChange(() => this.update());
   }
@@ -35,10 +17,10 @@ export class Sketchbook extends Examples {
     this.update();
   }
 
-  private update() {
+  protected override update(): void {
     this.sketchService.getSketches({}).then((container) => {
       this.register(container);
-      this.mainMenuManager.update();
+      this.menuManager.update();
     });
   }
 
@@ -50,7 +32,7 @@ export class Sketchbook extends Examples {
     );
   }
 
-  protected register(container: SketchContainer): void {
+  private register(container: SketchContainer): void {
     this.toDispose.dispose();
     this.registerRecursively(
       [...container.children, ...container.sketches],
@@ -62,24 +44,19 @@ export class Sketchbook extends Examples {
   protected override createHandler(uri: string): CommandHandler {
     return {
       execute: async () => {
-        let sketch: SketchRef | undefined = undefined;
         try {
-          sketch = await this.sketchService.loadSketch(uri);
+          await this.commandService.executeCommand(
+            OpenSketch.Commands.OPEN_SKETCH.id,
+            uri
+          );
         } catch (err) {
           if (SketchesError.NotFound.is(err)) {
-            // To handle the following:
-            // Open IDE2, delete a sketch from sketchbook, click on File > Sketchbook > the deleted sketch.
-            // Filesystem watcher misses out delete events on macOS; hence IDE2 has no chance to update the menu items.
-            this.messageService.error(err.message);
+            // Force update the menu items to remove the absent sketch.
             this.update();
+          } else {
+            throw err;
           }
         }
-        if (sketch) {
-          await this.commandService.executeCommand(
-            OpenSketch.Commands.OPEN_SKETCH.id,
-            sketch
-          );
-        }
       },
     };
   }