Refresh menus when opening example/recent fails.

Closes #53

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

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

@@ -21,16 +21,22 @@ import {
   MenuModelRegistry,
 } from './contribution';
 import { NotificationCenter } from '../notification-center';
-import { Board, SketchRef, SketchContainer } from '../../common/protocol';
+import {
+  Board,
+  SketchRef,
+  SketchContainer,
+  SketchesError,
+  Sketch,
+} from '../../common/protocol';
 import { nls } from '@theia/core/lib/common';
 
 @injectable()
 export abstract class Examples extends SketchContribution {
   @inject(CommandRegistry)
-  protected readonly commandRegistry: CommandRegistry;
+  private readonly commandRegistry: CommandRegistry;
 
   @inject(MenuModelRegistry)
-  protected readonly menuRegistry: MenuModelRegistry;
+  private readonly menuRegistry: MenuModelRegistry;
 
   @inject(MainMenuManager)
   protected readonly menuManager: MainMenuManager;
@@ -50,10 +56,16 @@ 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(options?: {
+    board?: Board | undefined;
+    forceRefresh?: boolean;
+  }): 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,23 +161,54 @@ 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
-        );
+        const sketch = await this.clone(uri);
+        if (sketch) {
+          try {
+            return this.commandService.executeCommand(
+              OpenSketch.Commands.OPEN_SKETCH.id,
+              sketch
+            );
+          } catch (err) {
+            if (SketchesError.NotFound.is(err)) {
+              // Do not toast the error message. It's handled by the `Open Sketch` command.
+              this.update({
+                board: this.boardsServiceClient.boardsConfig.selectedBoard,
+                forceRefresh: true,
+              });
+            } else {
+              throw err;
+            }
+          }
+        }
       },
     };
   }
+
+  private async clone(uri: string): Promise<Sketch | undefined> {
+    try {
+      const sketch = await this.sketchService.cloneExample(uri);
+      return sketch;
+    } catch (err) {
+      if (SketchesError.NotFound.is(err)) {
+        this.messageService.error(err.message);
+        this.update({
+          board: this.boardsServiceClient.boardsConfig.selectedBoard,
+          forceRefresh: true,
+        });
+      } else {
+        throw err;
+      }
+    }
+  }
 }
 
 @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,34 +240,37 @@ 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(
-    board: Board | undefined = this.boardsServiceClient.boardsConfig
-      .selectedBoard
+  protected override async update(
+    options: { board?: Board; forceRefresh?: boolean } = {
+      board: this.boardsServiceClient.boardsConfig.selectedBoard,
+    }
   ): Promise<void> {
+    const { board, forceRefresh } = options;
     return this.queue.add(async () => {
       this.toDispose.dispose();
       const fqbn = board?.fqbn;
       const name = board?.name;
       // Shows all examples when no board is selected, or the platform of the currently selected board is not installed.
       const { user, current, any } = await this.examplesService.installed({
         fqbn,
+        forceRefresh,
       });
       if (user.length) {
         (user as any).unshift(

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

@@ -1,7 +1,6 @@
 import { nls } from '@theia/core/lib/common';
 import { injectable } from '@theia/core/shared/inversify';
 import { ArduinoMenus } from '../menu/arduino-menus';
-import { ArduinoToolbar } from '../toolbar/arduino-toolbar';
 import {
   SketchContribution,
   URI,
@@ -17,11 +16,6 @@ export class NewSketch extends SketchContribution {
     registry.registerCommand(NewSketch.Commands.NEW_SKETCH, {
       execute: () => this.newSketch(),
     });
-    registry.registerCommand(NewSketch.Commands.NEW_SKETCH__TOOLBAR, {
-      isVisible: (widget) =>
-        ArduinoToolbar.is(widget) && widget.side === 'left',
-      execute: () => registry.executeCommand(NewSketch.Commands.NEW_SKETCH.id),
-    });
   }
 
   override registerMenus(registry: MenuModelRegistry): void {
@@ -54,8 +48,5 @@ export namespace NewSketch {
     export const NEW_SKETCH: Command = {
       id: 'arduino-new-sketch',
     };
-    export const NEW_SKETCH__TOOLBAR: Command = {
-      id: 'arduino-new-sketch--toolbar',
-    };
   }
 }

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 {
@@ -33,7 +34,7 @@ export class OpenRecentSketch extends SketchContribution {
   @inject(NotificationCenter)
   protected readonly notificationCenter: NotificationCenter;
 
-  protected toDisposeBeforeRegister = new Map<string, DisposableCollection>();
+  protected toDispose = new DisposableCollection();
 
   override onStart(): void {
     this.notificationCenter.onRecentSketchesDidChange(({ sketches }) =>
@@ -42,8 +43,12 @@ export class OpenRecentSketch extends SketchContribution {
   }
 
   override async onReady(): Promise<void> {
+    this.update();
+  }
+
+  private update(forceUpdate?: boolean): void {
     this.sketchService
-      .recentlyOpenedSketches()
+      .recentlyOpenedSketches(forceUpdate)
       .then((sketches) => this.refreshMenu(sketches));
   }
 
@@ -62,19 +67,25 @@ export class OpenRecentSketch extends SketchContribution {
 
   protected register(sketches: Sketch[]): void {
     const order = 0;
+    this.toDispose.dispose();
     for (const sketch of sketches) {
       const { uri } = sketch;
-      const toDispose = this.toDisposeBeforeRegister.get(uri);
-      if (toDispose) {
-        toDispose.dispose();
-      }
       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(true);
+            } else {
+              throw err;
+            }
+          }
+        },
       };
       this.commandRegistry.registerCommand(command, handler);
       this.menuRegistry.registerMenuAction(
@@ -85,17 +96,16 @@ export class OpenRecentSketch extends SketchContribution {
           order: String(order),
         }
       );
-      this.toDisposeBeforeRegister.set(
-        sketch.uri,
+      this.toDispose.pushAll([
         new DisposableCollection(
           Disposable.create(() =>
             this.commandRegistry.unregisterCommand(command)
           ),
           Disposable.create(() =>
             this.menuRegistry.unregisterMenuAction(command)
           )
-        )
-      );
+        ),
+      ]);
     }
   }
 }