fix: do not prompt invalid sketch folder names

Signed-off-by: Akos Kitta <a.kitta@arduino.cc>

Author: Akos Kitta

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

@@ -7,7 +7,6 @@ import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { WorkspaceInput } from '@theia/workspace/lib/browser/workspace-service';
-import * as dateFormat from 'dateformat';
 import { CurrentSketch } from '../sketches-service-client-impl';
 import { StartupTask } from '../../electron-common/startup-task';
 import { ArduinoMenus } from '../menu/arduino-menus';
@@ -143,10 +142,9 @@ export class SaveAsSketch extends CloudSketchContribution {
 
     // If target does not exist, propose a `directories.user`/${sketch.name} path
     // If target exists, propose `directories.user`/${sketch.name}_copy_${yyyymmddHHMMss}
+    // IDE2 must never prompt an invalid sketch folder name (https://github.com/arduino/arduino-ide/pull/1833#issuecomment-1412569252)
     const defaultUri = containerDirUri.resolve(
-      exists
-        ? `${sketch.name}_copy_${dateFormat(new Date(), 'yyyymmddHHMMss')}`
-        : sketch.name
+      Sketch.toValidSketchFolderName(sketch.name, exists)
     );
     const defaultPath = await this.fileService.fsPath(defaultUri);
     return await this.promptLocalSketchFolderDestination(defaultPath);

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

@@ -1,5 +1,6 @@
 import { ApplicationError } from '@theia/core/lib/common/application-error';
 import { nls } from '@theia/core/lib/common/nls';
+import * as dateFormat from 'dateformat';
 import URI from '@theia/core/lib/common/uri';
 
 export namespace SketchesError {
@@ -152,6 +153,12 @@ 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 defaultSketchFolderName = 'sketch';
+  // (non-API) exported for the tests
+  export const defaultFallbackFirstChar = '0';
+  // (non-API) exported for the tests
+  export const defaultFallbackChar = '_';
   // (non-API) exported for the tests
   export const invalidSketchFolderNameMessage = nls.localize(
     'arduino/sketch/invalidSketchName',
@@ -186,15 +193,43 @@ export namespace Sketch {
   }
 
   /**
-   * 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.
+   * Transforms the `candidate` argument into a valid sketch folder name by replacing all invalid characters with underscore (`_`) and trimming the string after 63 characters.
+   * If the argument is falsy, returns with `"sketch"`.
    */
-  export function toValidCloudSketchFolderName(candidate: string): string {
-    const errorMessage = validateSketchFolderName(candidate);
-    if (errorMessage) {
-      throw new Error(errorMessage);
+  export function toValidSketchFolderName(
+    candidate: string,
+    appendTimestampSuffix: boolean | Date = false
+  ): string {
+    const validName = candidate
+      ? candidate
+          .replace(/^[^0-9a-zA-Z]{1}/g, defaultFallbackFirstChar)
+          .replace(/[^0-9a-zA-Z_\.-]/g, defaultFallbackChar)
+          .slice(0, 63)
+      : defaultSketchFolderName;
+    if (appendTimestampSuffix) {
+      return `${validName.slice(0, 63 - timestampSuffixLength)}${
+        typeof appendTimestampSuffix === 'boolean'
+          ? timestampSuffix()
+          : timestampSuffix(appendTimestampSuffix)
+      }`;
     }
-    return candidate.replace(/\./g, '_').replace(/-/g, '_').slice(0, 36);
+    return validName;
+  }
+
+  const copy = '_copy_';
+  const datetimeFormat = 'yyyymmddHHMMss';
+  const timestampSuffixLength = copy.length + datetimeFormat.length;
+  function timestampSuffix(now = new Date()): string {
+    return `${copy}${dateFormat(now, datetimeFormat)}`;
+  }
+
+  /**
+   * Transforms the `candidate` argument into a valid cloud sketch folder name by replacing all invalid characters with underscore and trimming the string after 36 characters.
+   */
+  export function toValidCloudSketchFolderName(candidate: string): string {
+    return candidate
+      ? candidate.replace(/[^0-9a-zA-Z_]/g, defaultFallbackChar).slice(0, 36)
+      : defaultSketchFolderName;
   }
 
   export function is(arg: unknown): arg is Sketch {

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

@@ -69,51 +69,77 @@ describe('sketch', () => {
     });
   });
 
+  describe('toValidSketchFolderName', () => {
+    [
+      ['', Sketch.defaultSketchFolderName],
+      [' ', Sketch.defaultFallbackFirstChar],
+      ['  ', Sketch.defaultFallbackFirstChar + Sketch.defaultFallbackChar],
+      [
+        '0123456789012345678901234567890123456789012345678901234567890123',
+        '012345678901234567890123456789012345678901234567890123456789012',
+      ],
+      ['foo bar', 'foo_bar'],
+      ['vAlid', 'vAlid'],
+    ].map(([input, expected]) =>
+      toMapIt(input, expected, Sketch.toValidSketchFolderName)
+    );
+  });
+
+  describe('toValidSketchFolderName with timestamp suffix', () => {
+    const epoch = new Date(0);
+    const epochSuffix = '_copy_19700101010000';
+    [
+      ['', Sketch.defaultSketchFolderName + epochSuffix],
+      [' ', Sketch.defaultFallbackFirstChar + epochSuffix],
+      [
+        '  ',
+        Sketch.defaultFallbackFirstChar +
+          Sketch.defaultFallbackChar +
+          epochSuffix,
+      ],
+      [
+        '0123456789012345678901234567890123456789012345678901234567890123',
+        '0123456789012345678901234567890123456789012' + epochSuffix,
+      ],
+      ['foo bar', 'foo_bar' + epochSuffix],
+      ['vAlid', 'vAlid' + epochSuffix],
+    ].map(([input, expected]) =>
+      toMapIt(input, expected, (input: string) =>
+        Sketch.toValidSketchFolderName(input, epoch)
+      )
+    );
+  });
+
   describe('toValidCloudSketchFolderName', () => {
-    (
+    [
+      ['sketch', 'sketch'],
+      ['can-contain-slash-and-dot.ino', 'can_contain_slash_and_dot_ino'],
+      ['regex++', 'regex__'],
+      ['dots...', 'dots___'],
+      ['No Spaces', 'No_Spaces'],
+      ['_startsWithUnderscore', '_startsWithUnderscore'],
+      ['Invalid+Char.ino', 'Invalid_Char_ino'],
+      ['', 'sketch'],
+      ['/', '_'],
+      ['//trash/', '__trash_'],
       [
-        ['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);
-        }
-      });
-    });
+        '63Length_012345678901234567890123456789012345678901234567890123',
+        '63Length_012345678901234567890123456',
+      ],
+    ].map(([input, expected]) =>
+      toMapIt(input, expected, Sketch.toValidCloudSketchFolderName, true)
+    );
   });
 });
+
+function toMapIt(
+  input: string,
+  expected: string,
+  testMe: (input: string) => string,
+  cloud = false
+): Mocha.Test {
+  return it(`should map the '${input}' ${
+    cloud ? 'cloud ' : ''
+  }sketch folder name to '${expected}'`, () =>
+    expect(testMe(input)).to.be.equal(expected));
+}