fix: enforce valid sketch folder name on Save as

Closes #1599

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

Author: Akos Kitta

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

@@ -30,7 +30,13 @@ import { CloudSketchbookTreeWidget } from '../widgets/cloud-sketchbook/cloud-ske
 import { SketchbookCommands } from '../widgets/sketchbook/sketchbook-commands';
 import { SketchbookWidget } from '../widgets/sketchbook/sketchbook-widget';
 import { SketchbookWidgetContribution } from '../widgets/sketchbook/sketchbook-widget-contribution';
-import { Command, CommandRegistry, Contribution, URI } from './contribution';
+import {
+  Command,
+  CommandRegistry,
+  Contribution,
+  Sketch,
+  URI,
+} from './contribution';
 
 @injectable()
 export class NewCloudSketch extends Contribution {
@@ -234,14 +240,7 @@ export class NewCloudSketch extends Contribution {
               input
             );
           }
-          // This is how https://create.arduino.cc/editor/ works when renaming a sketch.
-          if (/^[0-9a-zA-Z_]{1,36}$/.test(input)) {
-            return '';
-          }
-          return nls.localize(
-            'arduino/newCloudSketch/invalidSketchName',
-            'The name must consist of basic letters, numbers, or underscores. The maximum length is 36 characters.'
-          );
+          return Sketch.validateCloudSketchFolderName(input) ?? '';
         },
       },
       this.labelProvider,

arduino-ide-extension/src/browser/contributions/save-as-sketch.ts

@@ -3,6 +3,7 @@ import * as remote from '@theia/core/electron-shared/@electron/remote';
 import * as dateFormat from 'dateformat';
 import { ArduinoMenus } from '../menu/arduino-menus';
 import {
+  Sketch,
   SketchContribution,
   URI,
   Command,
@@ -90,20 +91,9 @@ export class SaveAsSketch extends SketchContribution {
         : sketch.name
     );
     const defaultPath = await this.fileService.fsPath(defaultUri);
-    const { filePath, canceled } = await remote.dialog.showSaveDialog(
-      remote.getCurrentWindow(),
-      {
-        title: nls.localize(
-          'arduino/sketch/saveFolderAs',
-          'Save sketch folder as...'
-        ),
-        defaultPath,
-      }
+    const destinationUri = await this.promptSketchFolderDestination(
+      defaultPath
     );
-    if (!filePath || canceled) {
-      return false;
-    }
-    const destinationUri = await this.fileSystemExt.getUri(filePath);
     if (!destinationUri) {
       return false;
     }
@@ -133,6 +123,67 @@ export class SaveAsSketch extends SketchContribution {
     return !!workspaceUri;
   }
 
+  /**
+   * Prompts for the new sketch folder name until a valid one is give,
+   * then resolves with the destination sketch folder URI string,
+   * or `undefined` if the operation was canceled.
+   */
+  private async promptSketchFolderDestination(
+    defaultPath: string
+  ): Promise<string | undefined> {
+    let sketchFolderDestinationUri: string | undefined;
+    while (!sketchFolderDestinationUri) {
+      const { filePath } = await remote.dialog.showSaveDialog(
+        remote.getCurrentWindow(),
+        {
+          title: nls.localize(
+            'arduino/sketch/saveFolderAs',
+            'Save sketch folder as...'
+          ),
+          defaultPath,
+        }
+      );
+      if (!filePath) {
+        return undefined;
+      }
+      const destinationUri = await this.fileSystemExt.getUri(filePath);
+      const sketchFolderName = new URI(destinationUri).path.base;
+      const errorMessage = Sketch.validateSketchFolderName(sketchFolderName);
+      if (errorMessage) {
+        const message = `
+${nls.localize(
+  'arduino/sketch/invalidSketchFolderNameTitle',
+  "Invalid sketch folder name: '{0}'",
+  sketchFolderName
+)}
+
+${errorMessage}
+
+${nls.localize(
+  'arduino/sketch/editInvalidSketchFolderName',
+  'Do you want to try to save the sketch folder with a different name?'
+)}`.trim();
+        defaultPath = filePath;
+        const { response } = await remote.dialog.showMessageBox(
+          remote.getCurrentWindow(),
+          {
+            message,
+            buttons: [
+              nls.localize('vscode/issueMainService/cancel', 'Cancel'),
+              nls.localize('vscode/extensionsUtils/yes', 'Yes'),
+            ],
+        });
+        // cancel
+        if (response === 0) {
+          return undefined;
+        }
+      } else {
+        sketchFolderDestinationUri = destinationUri;
+      }
+    }
+    return sketchFolderDestinationUri;
+  }
+
   private async saveOntoCopiedSketch(mainFileUri: string, sketchUri: string, newSketchUri: string): Promise<void> {
     const widgets = this.applicationShell.widgets;
     const snapshots = new Map<string, object>();

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

@@ -1,28 +1,112 @@
-import { injectable } from '@theia/core/shared/inversify';
-import { CommandHandler } from '@theia/core/lib/common/command';
-import { MenuModelRegistry } from './contribution';
+import * as remote from '@theia/core/electron-shared/@electron/remote';
+import type { CommandHandler } from '@theia/core/lib/common/command';
+import { nls } from '@theia/core/lib/common/nls';
+import { waitForEvent } from '@theia/core/lib/common/promise-util';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { SketchContainer, SketchesError } from '../../common/protocol';
 import { ArduinoMenus } from '../menu/arduino-menus';
+import { WindowServiceExt } from '../theia/core/window-service-ext';
+import { MenuModelRegistry, URI } from './contribution';
 import { Examples } from './examples';
-import { SketchContainer, SketchesError } from '../../common/protocol';
 import { OpenSketch } from './open-sketch';
-import { nls } from '@theia/core/lib/common/nls';
 
 @injectable()
 export class Sketchbook extends Examples {
+  @inject(WindowServiceExt)
+  private readonly windowService: WindowServiceExt;
+  private _currentSketchbookPath: string | undefined;
+
   override onStart(): void {
     this.sketchServiceClient.onSketchbookDidChange(() => this.update());
     this.configService.onDidChangeSketchDirUri(() => this.update());
+    // If this window is changing the settings, and sketchbook location is included in the changeset,
+    // then the users must be warned about the invalid sketches from the new sketchbook.
+    this.settingsService.onWillChangeSoon(async (unsavedSettings) => {
+      // The sketchbook location is about to change.
+      if (unsavedSettings.sketchbookPath !== this._currentSketchbookPath) {
+        // Listen on both the settings and sketchbook location did change events
+        const timeout = 5_000;
+        const results = await Promise.allSettled([
+          waitForEvent(this.settingsService.onDidChange, timeout),
+          waitForEvent(this.configService.onDidChangeSketchDirUri, timeout),
+        ]);
+        if (results.every(({ status }) => status === 'fulfilled')) {
+          this.doUpdate(true);
+        } else {
+          console.warn(
+            'Expected the sketchbook location to change but it did not.'
+          );
+        }
+      }
+    });
+    const maybeUpdateCurrentSketchbookPath = async (
+      sketchDirUri: URI | undefined = this.configService.tryGetSketchDirUri()
+    ) => {
+      if (sketchDirUri) {
+        const candidateSketchbookPath = await this.fileService.fsPath(
+          sketchDirUri
+        );
+        if (candidateSketchbookPath !== this._currentSketchbookPath) {
+          this._currentSketchbookPath = candidateSketchbookPath;
+        }
+      }
+    };
+    this.configService.onDidChangeSketchDirUri(
+      maybeUpdateCurrentSketchbookPath
+    );
+    maybeUpdateCurrentSketchbookPath();
   }
 
   override async onReady(): Promise<void> {
-    this.update();
+    this.windowService
+      .isFirstWindow()
+      // only the first window should warn about invalid sketch folder names.
+      .then((firstWindow) => this.doUpdate(firstWindow));
   }
 
   protected override update(): void {
-    this.sketchService.getSketches({}).then((container) => {
-      this.register(container);
-      this.menuManager.update();
-    });
+    // on regular menu updates, do not raise warning dialogs about invalid sketch folder names
+    this.doUpdate(false);
+  }
+
+  private doUpdate(raiseInvalidSketchFoldersWarning?: boolean): void {
+    this.sketchService
+      .getSketches({})
+      .then(({ container, sketchesInInvalidFolder }) => {
+        if (
+          raiseInvalidSketchFoldersWarning &&
+          sketchesInInvalidFolder.length
+        ) {
+          Promise.all(
+            sketchesInInvalidFolder.map(async (ref) => {
+              const fsPath = await this.fileService.fsPath(new URI(ref.uri));
+              return {
+                name: ref.name,
+                path: fsPath,
+              };
+            })
+          ).then((dialogInputs) =>
+            dialogInputs.reduce(async (acc, { name, path }) => {
+              await acc;
+              return remote.dialog.showMessageBox(remote.getCurrentWindow(), {
+                title: nls.localize(
+                  'arduino/sketch/ignoringSketchWithBadNameTitle',
+                  'Ignoring sketch with bad name'
+                ),
+                message: nls.localize(
+                  'arduino/sketch/ignoringSketchWithBadNameMessage',
+                  'The sketch "{0}" cannot be used. Sketch names must contain only basic letters and numbers. (ASCII-only with no spaces, and it cannot start with a number). To get rid of this message, remove the sketch from {1}',
+                  name,
+                  path
+                ),
+                type: 'warning',
+              }) as Promise<unknown>;
+            }, Promise.resolve())
+          );
+        }
+        this.register(container);
+        this.menuManager.update();
+      });
   }
 
   override registerMenus(registry: MenuModelRegistry): void {

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

@@ -27,7 +27,7 @@ export interface VerifySketchParams {
 }
 
 /**
- *  - `"idle"` when neither verify, not upload is running,
+ *  - `"idle"` when neither verify, nor upload is running,
  *  - `"explicit-verify"` when only verify is running triggered by the user, and
  *  - `"automatic-verify"` is when the automatic verify phase is running as part of an upload triggered by the user.
  */

arduino-ide-extension/src/browser/dialogs/settings/settings.ts

@@ -112,6 +112,10 @@ export class SettingsService {
   readonly onDidChange = this.onDidChangeEmitter.event;
   protected readonly onDidResetEmitter = new Emitter<Readonly<Settings>>();
   readonly onDidReset = this.onDidResetEmitter.event;
+  protected readonly onWillChangeSoonEmitter = new Emitter<
+    Readonly<Settings>
+  >();
+  readonly onWillChangeSoon = this.onWillChangeSoonEmitter.event;
 
   protected ready = new Deferred<void>();
   protected _settings: Settings;
@@ -304,6 +308,7 @@ export class SettingsService {
     (config as any).sketchDirUri = sketchDirUri;
     (config as any).network = network;
     (config as any).locale = currentLanguage;
+    this.onWillChangeSoonEmitter.fire(this._settings);
 
     await Promise.all([
       this.savePreference('editor.fontSize', editorFontSize),
@@ -319,7 +324,6 @@ export class SettingsService {
       this.savePreference(SHOW_ALL_FILES_SETTING, sketchbookShowAllFiles),
       this.configService.setConfiguration(config),
     ]);
-    this.onDidChangeEmitter.fire(this._settings);
 
     // after saving all the settings, if we need to change the language we need to perform a reload
     // Only reload if the language differs from the current locale. `nls.locale === undefined` signals english as well
@@ -335,6 +339,7 @@ export class SettingsService {
       this.commandService.executeCommand(ElectronCommands.RELOAD.id);
     }
 
+    this.onDidChangeEmitter.fire(this._settings);
     return true;
   }
 }

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

@@ -90,7 +90,7 @@ export class SketchesServiceClientImpl
     if (!sketchDirUri) {
       return;
     }
-    const container = await this.sketchService.getSketches({
+    const { container } = await this.sketchService.getSketches({
       uri: sketchDirUri.toString(),
     });
     for (const sketch of SketchContainer.toArray(container)) {

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

@@ -1,4 +1,5 @@
 import { ApplicationError } from '@theia/core/lib/common/application-error';
+import { nls } from '@theia/core/lib/common/nls';
 import URI from '@theia/core/lib/common/uri';
 
 export namespace SketchesError {
@@ -31,9 +32,14 @@ export const SketchesService = Symbol('SketchesService');
 export interface SketchesService {
   /**
    * Resolves to a sketch container representing the hierarchical structure of the sketches.
-   * If `uri` is not given, `directories.user` will be user instead.
+   * If `uri` is not given, `directories.user` will be user instead. The `sketchesInInvalidFolder`
+   * array might contain sketches that were discovered, but due to their invalid name they were removed
+   * from the `container`.
    */
-  getSketches({ uri }: { uri?: string }): Promise<SketchContainer>;
+  getSketches({ uri }: { uri?: string }): Promise<{
+    container: SketchContainer;
+    sketchesInInvalidFolder: SketchRef[];
+  }>;
 
   /**
    * This is the TS implementation of `SketchLoad` from the CLI and should be replaced with a gRPC call eventually.
@@ -140,6 +146,51 @@ export interface Sketch extends SketchRef {
   readonly rootFolderFileUris: string[]; // `RootFolderFiles` (does not include the main sketch file)
 }
 export namespace Sketch {
+  // (non-API) exported for the tests
+  export const invalidSketchFolderNameMessage = nls.localize(
+    'arduino/sketch/invalidSketchName',
+    'Sketch names must start with a letter or number, followed by letters, numbers, dashes, dots and underscores. Maximum length is 63 characters.'
+  );
+  const invalidCloudSketchFolderNameMessage = nls.localize(
+    'arduino/sketch/invalidCloudSketchName',
+    'The name must consist of basic letters, numbers, or underscores. The maximum length is 36 characters.'
+  );
+  /**
+   * `undefined` if the candidate sketch folder name is valid. Otherwise, the validation error message.
+   * Based on the [specs](https://arduino.github.io/arduino-cli/latest/sketch-specification/#sketch-folders-and-files).
+   */
+  export function validateSketchFolderName(
+    candidate: string
+  ): string | undefined {
+    return /^[0-9a-zA-Z]{1}[0-9a-zA-Z_\.-]{0,62}$/.test(candidate)
+      ? undefined
+      : invalidSketchFolderNameMessage;
+  }
+
+  /**
+   * `undefined` if the candidate cloud sketch folder name is valid. Otherwise, the validation error message.
+   * Based on how https://create.arduino.cc/editor/ works.
+   */
+  export function validateCloudSketchFolderName(
+    candidate: string
+  ): string | undefined {
+    return /^[0-9a-zA-Z_]{1,36}$/.test(candidate)
+      ? undefined
+      : invalidCloudSketchFolderNameMessage;
+  }
+
+  /**
+   * Transforms the valid local sketch name into a valid cloud sketch name by replacing dots and dashes with underscore and trimming the length after 36 characters.
+   * Throws an error if `candidate` is not valid.
+   */
+  export function toValidCloudSketchFolderName(candidate: string): string {
+    const errorMessage = validateSketchFolderName(candidate);
+    if (errorMessage) {
+      throw new Error(errorMessage);
+    }
+    return candidate.replace(/\./g, '_').replace(/-/g, '_').slice(0, 36);
+  }
+
   export function is(arg: unknown): arg is Sketch {
     if (!SketchRef.is(arg)) {
       return false;

arduino-ide-extension/src/node/sketches-service-impl.ts

@@ -79,16 +79,25 @@ export class SketchesServiceImpl
   @inject(IsTempSketch)
   private readonly isTempSketch: IsTempSketch;
 
-  async getSketches({ uri }: { uri?: string }): Promise<SketchContainer> {
+  async getSketches({ uri }: { uri?: string }): Promise<{
+    container: SketchContainer;
+    sketchesInInvalidFolder: SketchRef[];
+  }> {
     const root = await this.root(uri);
     if (!root) {
       this.logger.warn(`Could not derive sketchbook root from ${uri}.`);
-      return SketchContainer.create('');
+      return {
+        container: SketchContainer.create(''),
+        sketchesInInvalidFolder: [],
+      };
     }
     const rootExists = await exists(root);
     if (!rootExists) {
       this.logger.warn(`Sketchbook root ${root} does not exist.`);
-      return SketchContainer.create('');
+      return {
+        container: SketchContainer.create(''),
+        sketchesInInvalidFolder: [],
+      };
     }
     const container = <Mutable<SketchContainer>>(
       SketchContainer.create(uri ? path.basename(root) : 'Sketchbook')
@@ -754,7 +763,10 @@ export async function discoverSketches(
   root: string,
   container: Mutable<SketchContainer>,
   logger?: ILogger
-): Promise<SketchContainer> {
+): Promise<{
+  container: SketchContainer;
+  sketchesInInvalidFolder: SketchRef[];
+}> {
   const pathToAllSketchFiles = await globSketches(
     '/!(libraries|hardware)/**/*.{ino,pde}',
     root
@@ -818,7 +830,7 @@ export async function discoverSketches(
 
   // If the container has a sketch with the same name, it cannot have a child container.
   // See above example about how to ignore nested sketches.
-  const prune = (
+  const pruneNestedSketches = (
     container: Mutable<SketchContainer>
   ): Mutable<SketchContainer> => {
     for (const sketch of container.sketches) {
@@ -829,7 +841,23 @@ export async function discoverSketches(
         container.children.splice(childContainerIndex, 1);
       }
     }
-    container.children.forEach(prune);
+    container.children.forEach(pruneNestedSketches);
+    return container;
+  };
+
+  const sketchesInInvalidFolder: SketchRef[] = [];
+  const pruneInvalidSketchFolders = (
+    container: Mutable<SketchContainer>
+  ): Mutable<SketchContainer> => {
+    for (let i = container.sketches.length - 1; i >= 0; i--) {
+      const sketch = container.sketches[i];
+      const errorMessage = Sketch.validateSketchFolderName(sketch.name);
+      if (errorMessage) {
+        container.sketches.splice(i, 1);
+        sketchesInInvalidFolder.push(sketch);
+      }
+    }
+    container.children.forEach(pruneInvalidSketchFolders);
     return container;
   };
 
@@ -876,7 +904,13 @@ export async function discoverSketches(
       uri: FileUri.create(path.dirname(pathToSketchFile)).toString(),
     });
   }
-  return prune(container);
+  let pruned = pruneNestedSketches(container);
+  pruned = pruneInvalidSketchFolders(container);
+  // Same order as in `File` > `Sketchbook`
+  sketchesInInvalidFolder.sort((left, right) =>
+    left.name.toLocaleLowerCase().localeCompare(right.name)
+  );
+  return { container: pruned, sketchesInInvalidFolder };
 }
 
 async function globSketches(pattern: string, root: string): Promise<string[]> {

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

@@ -0,0 +1,119 @@
+import { expect } from 'chai';
+import { Sketch } from '../../common/protocol';
+
+describe('sketch', () => {
+  describe('validateSketchFolderName', () => {
+    (
+      [
+        ['sketch', true],
+        ['can-contain-slash-and-dot.ino', true],
+        ['regex++', false],
+        ['dots...', true],
+        ['No Spaces', false],
+        ['_invalidToStartWithUnderscore', false],
+        ['Invalid+Char.ino', false],
+        ['', false],
+        ['/', false],
+        ['//trash/', false],
+        [
+          '63Length_012345678901234567890123456789012345678901234567890123',
+          true,
+        ],
+        [
+          'TooLong__0123456789012345678901234567890123456789012345678901234',
+          false,
+        ],
+      ] as [string, boolean][]
+    ).map(([input, expected]) => {
+      it(`'${input}' should ${
+        !expected ? 'not ' : ''
+      }be a valid sketch folder name`, () => {
+        const actual = Sketch.validateSketchFolderName(input);
+        if (expected) {
+          expect(actual).to.be.undefined;
+        } else {
+          expect(actual).to.be.not.undefined;
+          expect(actual?.length).to.be.greaterThan(0);
+        }
+      });
+    });
+  });
+
+  describe('validateCloudSketchFolderName', () => {
+    (
+      [
+        ['sketch', true],
+        ['no-dashes', false],
+        ['no-dots', false],
+        ['No Spaces', false],
+        ['_canStartWithUnderscore', true],
+        ['Invalid+Char.ino', false],
+        ['', false],
+        ['/', false],
+        ['//trash/', false],
+        ['36Length_012345678901234567890123456', true],
+        ['TooLong__0123456789012345678901234567', false],
+      ] as [string, boolean][]
+    ).map(([input, expected]) => {
+      it(`'${input}' should ${
+        !expected ? 'not ' : ''
+      }be a valid cloud sketch folder name`, () => {
+        const actual = Sketch.validateCloudSketchFolderName(input);
+        if (expected) {
+          expect(actual).to.be.undefined;
+        } else {
+          expect(actual).to.be.not.undefined;
+          expect(actual?.length).to.be.greaterThan(0);
+        }
+      });
+    });
+  });
+
+  describe('toValidCloudSketchFolderName', () => {
+    (
+      [
+        ['sketch', 'sketch'],
+        ['can-contain-slash-and-dot.ino', 'can_contain_slash_and_dot_ino'],
+        ['regex++'],
+        ['dots...', 'dots___'],
+        ['No Spaces'],
+        ['_invalidToStartWithUnderscore'],
+        ['Invalid+Char.ino'],
+        [''],
+        ['/'],
+        ['//trash/'],
+        [
+          '63Length_012345678901234567890123456789012345678901234567890123',
+          '63Length_012345678901234567890123456',
+        ],
+        ['TooLong__0123456789012345678901234567890123456789012345678901234'],
+      ] as [string, string?][]
+    ).map(([input, expected]) => {
+      it(`'${input}' should ${expected ? '' : 'not '}map the ${
+        !expected ? 'invalid ' : ''
+      }sketch folder name to a valid cloud sketch folder name${
+        expected ? `: '${expected}'` : ''
+      }`, () => {
+        if (!expected) {
+          try {
+            Sketch.toValidCloudSketchFolderName(input);
+            throw new Error(
+              `Expected an error when mapping ${input} to a valid sketch folder name.`
+            );
+          } catch (err) {
+            if (err instanceof Error) {
+              expect(err.message).to.be.equal(
+                Sketch.invalidSketchFolderNameMessage
+              );
+            } else {
+              throw err;
+            }
+          }
+        } else {
+          const actual = Sketch.toValidCloudSketchFolderName(input);
+          expect(actual).to.be.equal(expected);
+        }
+      });
+    });
+  });
+});

arduino-ide-extension/src/test/node/__test_sketchbook__/bar++ 2/bar++ 2.ino

@@ -21,26 +21,41 @@ const emptySketchbook = join(testSketchbook, 'empty');
 
 describe('discover-sketches', () => {
   it('should recursively discover all sketches in a folder', async () => {
-    const actual = await discoverSketches(
+    const { container, sketchesInInvalidFolder } = await discoverSketches(
       testSketchbook,
       SketchContainer.create('test')
     );
-    containersDeepEquals(
-      actual,
+    objectDeepEquals(
+      container,
       expectedTestSketchbookContainer(
         testSketchbook,
         testSketchbookContainerTemplate
       )
     );
+    assert.equal(sketchesInInvalidFolder.length, 2);
+    objectDeepEquals(
+      sketchesInInvalidFolder[0],
+      adjustUri(testSketchbook, {
+        name: 'bar++',
+        uri: 'template://bar%2B%2B',
+      })
+    );
+    objectDeepEquals(
+      sketchesInInvalidFolder[1],
+      adjustUri(testSketchbook, {
+        name: 'bar++ 2',
+        uri: 'template://bar%2B%2B%202',
+      })
+    );
   });
 
   it('should handle when the sketchbook is a sketch folder', async () => {
-    const actual = await discoverSketches(
+    const { container } = await discoverSketches(
       sketchFolderAsSketchbook,
       SketchContainer.create('foo-bar')
     );
     const name = basename(sketchFolderAsSketchbook);
-    containersDeepEquals(actual, {
+    objectDeepEquals(container, {
       children: [],
       label: 'foo-bar',
       sketches: [
@@ -53,18 +68,15 @@ describe('discover-sketches', () => {
   });
 
   it('should handle empty sketchbook', async () => {
-    const actual = await discoverSketches(
+    const { container } = await discoverSketches(
       emptySketchbook,
       SketchContainer.create('empty')
     );
-    containersDeepEquals(actual, SketchContainer.create('empty'));
+    objectDeepEquals(container, SketchContainer.create('empty'));
   });
 });
 
-function containersDeepEquals(
-  actual: SketchContainer,
-  expected: SketchContainer
-) {
+function objectDeepEquals(actual: unknown, expected: unknown) {
   const stableActual = JSON.parse(stableJsonStringify(actual));
   const stableExpected = JSON.parse(stableJsonStringify(expected));
   assert.deepEqual(stableActual, stableExpected);
@@ -81,18 +93,10 @@ function expectedTestSketchbookContainer(
   containerTemplate: SketchContainer,
   label?: string
 ): SketchContainer {
-  let rootUri = FileUri.create(rootPath).toString();
-  if (rootUri.charAt(rootUri.length - 1) !== '/') {
-    rootUri += '/';
-  }
-  const adjustUri = (sketch: Mutable<SketchRef>) => {
-    assert.equal(sketch.uri.startsWith('template://'), true);
-    assert.equal(sketch.uri.startsWith('template:///'), false);
-    sketch.uri = sketch.uri.replace('template://', rootUri).toString();
-    return sketch;
-  };
   const adjustContainer = (container: SketchContainer) => {
-    container.sketches.forEach(adjustUri);
+    container.sketches.forEach((templateRef) =>
+      adjustUri(rootPath, templateRef)
+    );
     container.children.forEach(adjustContainer);
     return <Mutable<SketchContainer>>container;
   };
@@ -103,6 +107,20 @@ function expectedTestSketchbookContainer(
   return container;
 }
 
+function adjustUri(
+  rootPath: string,
+  templateRef: Mutable<SketchRef>
+): Mutable<SketchRef> {
+  let rootUri = FileUri.create(rootPath).toString();
+  if (rootUri.charAt(rootUri.length - 1) !== '/') {
+    rootUri += '/';
+  }
+  assert.equal(templateRef.uri.startsWith('template://'), true);
+  assert.equal(templateRef.uri.startsWith('template:///'), false);
+  templateRef.uri = templateRef.uri.replace('template://', rootUri).toString();
+  return templateRef;
+}
+
 const testSketchbookContainerTemplate: SketchContainer = {
   label: 'test',
   children: [
@@ -158,10 +176,6 @@ const testSketchbookContainerTemplate: SketchContainer = {
     },
   ],
   sketches: [
-    {
-      name: 'bar++',
-      uri: 'template://bar%2B%2B',
-    },
     {
       name: 'a_sketch',
       uri: 'template://a_sketch',

arduino-ide-extension/src/test/node/__test_sketchbook__/bar++/foo++/foo++.ino

@@ -310,7 +310,6 @@
       "unableToConnectToWebSocket": "Unable to connect to websocket"
     },
     "newCloudSketch": {
-      "invalidSketchName": "The name must consist of basic letters, numbers, or underscores. The maximum length is 36 characters.",
       "newSketchTitle": "Name of a new Remote Sketch",
       "notFound": "Could not pull the remote sketch '{0}'. It does not exist.",
       "sketchAlreadyExists": "Remote sketch '{0}' already exists."
@@ -404,7 +403,13 @@
       "createdArchive": "Created archive '{0}'.",
       "doneCompiling": "Done compiling.",
       "doneUploading": "Done uploading.",
+      "editInvalidSketchFolderName": "Do you want to try to save the sketch folder with a different name?",
       "exportBinary": "Export Compiled Binary",
+      "ignoringSketchWithBadNameMessage": "The sketch \"{0}\" cannot be used. Sketch names must contain only basic letters and numbers. (ASCII-only with no spaces, and it cannot start with a number). To get rid of this message, remove the sketch from {1}",
+      "ignoringSketchWithBadNameTitle": "Ignoring sketch with bad name",
+      "invalidCloudSketchName": "The name must consist of basic letters, numbers, or underscores. The maximum length is 36 characters.",
+      "invalidSketchFolderNameTitle": "Invalid sketch folder name: '{0}'",
+      "invalidSketchName": "Sketch names must start with a letter or number, followed by letters, numbers, dashes, dots and underscores. Maximum length is 63 characters.",
       "moving": "Moving",
       "movingMsg": "The file \"{0}\" needs to be inside a sketch folder named \"{1}\".\nCreate this folder, move the file, and continue?",
       "new": "New Sketch",