Merge pull request #68 from TurboWarp/platform

Add platform concept

Author: GarboMuffin

README.md

@@ -45,7 +45,9 @@ const run = async () => {
     // is not stable and may change without warning.
     logCallback: (message) => {
       console.log(message);
-    }
+    },
+    // Values: 'scratch' (default), 'turbowarp'
+    platform: 'scratch'
   };
   // To use the above options, just supply as the second argument when you call sb3fix:
   await sb3fix.fixZip(brokenZip, options);

src/sb3fix.js

@@ -8,8 +8,13 @@ License, v. 2.0. If a copy of the MPL was not distributed with this
 file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
+/**
+ * @typedef {'scratch'|'turbowarp'} Platform
+ */
+
 /**
  * @typedef Options
+ * @property {Platform} [platform] Defaults to 'scratch'.
  * @property {(message: string) => void} [logCallback]
  */
 
@@ -19,6 +24,35 @@ file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 const isObject = (obj) => !!obj && typeof obj === 'object';
 
+/**
+ * @typedef PlatformInfo
+ * @property {boolean} [allowsNonScalarVariables]
+ */
+
+/**
+ * @type {Record<Platform, PlatformInfo>}
+ */
+const platforms = {
+  scratch: {},
+  turbowarp: {
+    allowsNonScalarVariables: true
+  }
+};
+
+/**
+ * @param {Options} options
+ * @returns {PlatformInfo}
+ */
+const getPlatform = (options) => {
+  if (options && Object.prototype.hasOwnProperty.call(options, 'platform')) {
+    if (Object.prototype.hasOwnProperty.call(platforms, options.platform)) {
+      return platforms[options.platform];
+    }
+    throw new Error(`Unknown platform: ${options.platform}`);
+  }
+  return platforms.scratch;
+};
+
 const BUILTIN_EXTENSIONS = [
   'control',
   'data',
@@ -70,6 +104,8 @@ const getKnownExtensions = (project) => {
  * @returns {object} Fixed project.json object. If the `data` argument was an object, this will point to the same object.
  */
 const fixJSON = (data, options = {}) => {
+  const platform = getPlatform(options);
+
   /**
    * @param {string} message
    */
@@ -94,10 +130,12 @@ const fixJSON = (data, options = {}) => {
       variable[0] = String(variable[0]);
     }
 
-    const value = variable[1];
-    if (typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'boolean') {
-      log(`variable ${id} value was not a Scratch-compatible value`);
-      variable[1] = String(variable[1]);
+    if (!platform.allowsNonScalarVariables) {
+      const value = variable[1];
+      if (typeof value !== 'number' && typeof value !== 'string' && typeof value !== 'boolean') {
+        log(`variable ${id} value was not a Scratch-compatible value`);
+        variable[1] = String(variable[1]);
+      }
     }
   };
 
@@ -602,5 +640,6 @@ const fixZip = async (data, options = {}) => {
 
 module.exports = {
   fixJSON,
-  fixZip
+  fixZip,
+  platforms
 };

tests/expected-output/turbowarp/invalid-variable-values.sb3

@@ -0,0 +1,4 @@
+checking target 0
+list nf(jE2GO9Mw*c7)~RxKv value was not an array
+checking target 1
+list 3.vwk($=q-/jw5_[2z)2 index 0 was not a Scratch-compatible value

tests/expected-output/turbowarp/invalid-variable-values.txt

@@ -8,20 +8,57 @@ const sb3fix = require('../src/sb3fix');
 
 const inputDirectory = path.join(__dirname, 'samples');
 const outputDirectory = path.join(__dirname, 'expected-output');
+
+/** @type {Array<import('../src/sb3fix').Platform>} */
+const nonScratchPlatforms = Object.keys(sb3fix.platforms).filter(i => i !== 'scratch');
+
 const testcases = fs.readdirSync(inputDirectory)
   .filter(i => i.endsWith('.sb3') || i.endsWith('.sprite3'))
-  .sort()
-  .map(i => ({
-    name: i,
-    inputPath: path.join(inputDirectory, i),
-    outputProjectPath: path.join(outputDirectory, i),
-    outputLogPath: path.join(outputDirectory, i.replace(/\.(?:sb|sprite)3$/, '.txt')),
-  }));
-
-const runTestcase = async (testcase) => {
+  .sort();
+
+/**
+ * @typedef Result
+ * @property {Uint8Array} result
+ * @property {string} log
+ */
+
+/**
+ * @param {string} testcase
+ * @param {import('../src/sb3fix').Platform} platform
+ * @returns {string}
+ */
+const getOutputProjectPath = (testcase, platform) => {
+  if (platform === 'scratch') {
+    return path.join(outputDirectory, testcase);
+  }
+  return path.join(outputDirectory, platform, testcase);
+};
+
+/**
+ * 
+ * @param {string} testcase
+ * @param {import('../src/sb3fix').Platform} platform
+ * @returns {string}
+ */
+const getOutputLogPath = (testcase, platform) => {
+  const name = testcase.replace(/\.(?:sb|sprite)3$/, '.txt');
+  if (platform === 'scratch') {
+    return path.join(outputDirectory, name);
+  }
+  return path.join(outputDirectory, platform, name);
+};
+
+/**
+ * @param {string} testcase
+ * @param {import('../src/sb3fix').Platform} platform
+ * @returns {Promise<Result>}
+ */
+const runTestcase = async (testcase, platform) => {
   const logs = [];
-  const data = await fsPromises.readFile(testcase.inputPath);
+  const inputPath = path.join(inputDirectory, testcase);
+  const data = await fsPromises.readFile(inputPath);
   const result = await sb3fix.fixZip(data, {
+    platform,
     logCallback: (message) => {
       logs.push(message);
     }
@@ -32,35 +69,129 @@ const runTestcase = async (testcase) => {
   };
 };
 
+/**
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @returns {boolean}
+ */
+const areArraysShallowEqual = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+/**
+ * @param {Result} resultA
+ * @param {Result} resultB
+ * @returns {boolean}
+ */
+const isIdenticalResult = (resultA, resultB) => (
+  resultA.log === resultB.log &&
+  areArraysShallowEqual(resultA.result, resultB.result)
+);
+
+/**
+ * @param {Result} resultA
+ * @param {Result} resultB
+ */
+const assertIdenticalResults = (resultA, resultB) => {
+  assert.strictEqual(resultA.log, resultB.log, 'log');
+  assert.deepStrictEqual(resultA.result, resultB.result, 'project');
+};
+
 const validate = async () => {
   for (const testcase of testcases) {
-    await nodeTest(testcase, async (t) => {
-      const expectedFixedProject = new Uint8Array(await fsPromises.readFile(testcase.outputProjectPath));
-      const expectedLog = await fsPromises.readFile(testcase.outputLogPath, 'utf-8');
-      const result = await runTestcase(testcase);
+    await nodeTest(testcase, async () => {
+      /** @type {Result|null} */
+      let expectedScratchResult = null;
 
-      assert.equal(result.log, expectedLog, 'log');
-      assert.deepStrictEqual(result.result, expectedFixedProject, 'project');
+      await nodeTest("scratch", async () => {
+        expectedScratchResult = await readResult(testcase, 'scratch');
+        assert.notStrictEqual(expectedScratchResult, null, 'scratch expected result exists');
+
+        const actualResult = await runTestcase(testcase, 'scratch');
+        assertIdenticalResults(expectedScratchResult, actualResult);
+      });
+
+      for (const platform of nonScratchPlatforms) {
+        await nodeTest(platform, async () => {
+          const expectedResult = await readResult(testcase, platform) || expectedScratchResult;
+          const actualResult = await runTestcase(testcase, platform);
+          assertIdenticalResults(expectedResult, actualResult);
+        });
+      }
     });
   }
 };
 
+/**
+ * @param {string} testcase
+ * @param {import('../src/sb3fix').Platform} platform
+ * @returns {Promise<Result|null>}
+ */
+const readResult = async (testcase, platform) => {
+  const outputProjectPath = getOutputProjectPath(testcase, platform);
+  const outputLogPath = getOutputLogPath(testcase, platform);
+
+  try {
+    const result = new Uint8Array(await fsPromises.readFile(outputProjectPath));
+    const log = await fsPromises.readFile(outputLogPath, 'utf8');
+    return {
+      result,
+      log
+    };
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      return null;
+    }
+    throw e;
+  }
+};
+
+/**
+ * @param {string} testcase
+ * @param {import('../src/sb3fix').Platform} platform
+ * @param {Result} result 
+ */
+const writeResult = async (testcase, platform, result) => {
+  const outputProjectPath = getOutputProjectPath(testcase, platform);
+  const outputLogPath = getOutputLogPath(testcase, platform);
+
+  const directory = path.dirname(outputProjectPath);
+  await fsPromises.mkdir(directory, {
+    recursive: true
+  });
+
+  await fsPromises.writeFile(outputProjectPath, result.result);
+  await fsPromises.writeFile(outputLogPath, result.log);
+};
+
 const update = async () => {
   console.time('Updated snapshots');
 
   await fsPromises.rm(outputDirectory, {
     force: true,
     recursive: true
   });
-  await fsPromises.mkdir(outputDirectory, {
-    recursive: true
-  });
 
   for (const testcase of testcases) {
-    console.log(`${testcase.name} ...`);
-    const result = await runTestcase(testcase);
-    await fsPromises.writeFile(testcase.outputProjectPath, result.result);
-    await fsPromises.writeFile(testcase.outputLogPath, result.log);
+    console.log(`${testcase} ...`);
+
+    const scratchResult = await runTestcase(testcase, 'scratch');
+    await writeResult(testcase, 'scratch', scratchResult);
+
+    for (const platform of nonScratchPlatforms) {
+      const nonScratchResult = await runTestcase(testcase, platform);
+      if (!isIdenticalResult(scratchResult, nonScratchResult)) {
+        await writeResult(testcase, platform, nonScratchResult);
+      }
+    }
   }
 
   console.timeEnd('Updated snapshots');