Add flow for monorepo w/ independent versions

jest.config.js

@@ -28,12 +28,14 @@ module.exports = {
   coverageDirectory: 'coverage',
 
   // An array of regexp pattern strings used to skip coverage collection
-  // coveragePathIgnorePatterns: [
-  //   "/node_modules/"
-  // ],
+  coveragePathIgnorePatterns: [
+    '/node_modules/',
+    '/src/index.ts',
+    '/src/inputs-utils.ts',
+  ],
 
   // Indicates which provider should be used to instrument code for coverage
-  coverageProvider: 'v8',
+  coverageProvider: 'babel',
 
   // A list of reporter names that Jest uses when writing coverage reports
   coverageReporters: ['html', 'json-summary', 'text'],
@@ -110,7 +112,7 @@ module.exports = {
   resetMocks: true,
 
   // Reset the module registry before running each individual test
-  // resetModules: false,
+  resetModules: true,
 
   // A path to a custom resolver
   // resolver: undefined,
@@ -159,9 +161,7 @@ module.exports = {
   // ],
 
   // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-  // testPathIgnorePatterns: [
-  //   "/node_modules/"
-  // ],
+  testPathIgnorePatterns: ['/node_modules/', '/src/old/'],
 
   // The regexp pattern or array of patterns that Jest uses to detect test files
   // testRegex: [],

package.json

@@ -29,10 +29,16 @@
     "@metamask/eslint-config-jest": "^9.0.0",
     "@metamask/eslint-config-nodejs": "^9.0.0",
     "@metamask/eslint-config-typescript": "^9.0.1",
+    "@types/debug": "^4.1.7",
     "@types/jest": "^28.1.4",
+    "@types/jest-when": "^3.5.2",
     "@types/node": "^17.0.23",
+    "@types/rimraf": "^3.0.2",
+    "@types/which": "^2.0.1",
+    "@types/yargs": "^17.0.10",
     "@typescript-eslint/eslint-plugin": "^4.21.0",
     "@typescript-eslint/parser": "^4.21.0",
+    "deepmerge": "^4.2.2",
     "eslint": "^7.23.0",
     "eslint-config-prettier": "^8.1.0",
     "eslint-plugin-import": "^2.22.1",
@@ -42,9 +48,12 @@
     "eslint-plugin-prettier": "^3.3.1",
     "jest": "^28.0.0",
     "jest-it-up": "^2.0.2",
+    "jest-when": "^3.5.1",
+    "nanoid": "^3.3.4",
     "prettier": "^2.2.1",
     "prettier-plugin-packagejson": "^2.2.17",
     "rimraf": "^3.0.2",
+    "stdio-mock": "^1.2.0",
     "ts-jest": "^28.0.0",
     "ts-node": "^10.7.0",
     "typescript": "^4.2.4"
@@ -61,5 +70,16 @@
     "allowScripts": {
       "@lavamoat/preinstall-always-fail": false
     }
+  },
+  "dependencies": {
+    "@metamask/action-utils": "^0.0.2",
+    "@metamask/utils": "^2.0.0",
+    "debug": "^4.3.4",
+    "execa": "^5.0.0",
+    "glob": "^8.0.3",
+    "semver": "^7.3.7",
+    "which": "^2.0.2",
+    "yaml": "^2.1.1",
+    "yargs": "^17.5.1"
   }
 }

src/editor-utils.test.ts

@@ -0,0 +1,115 @@
+import { when } from 'jest-when';
+import { determineEditor } from './editor-utils';
+import * as envUtils from './env-utils';
+import * as miscUtils from './misc-utils';
+
+jest.mock('./env-utils');
+jest.mock('./misc-utils');
+
+describe('editor-utils', () => {
+  describe('determineEditor', () => {
+    it('returns information about the editor from EDITOR if it resolves to an executable', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockResolvedValue('/path/to/resolved-editor');
+
+      expect(await determineEditor()).toStrictEqual({
+        path: '/path/to/resolved-editor',
+        args: [],
+      });
+    });
+
+    it('falls back to VSCode if it exists and if EDITOR does not point to an executable', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockResolvedValue(null)
+        .calledWith('code')
+        .mockResolvedValue('/path/to/code');
+
+      expect(await determineEditor()).toStrictEqual({
+        path: '/path/to/code',
+        args: ['--wait'],
+      });
+    });
+
+    it('returns null if resolving EDITOR returns null and resolving VSCode returns null', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockResolvedValue(null)
+        .calledWith('code')
+        .mockResolvedValue(null);
+
+      expect(await determineEditor()).toBeNull();
+    });
+
+    it('returns null if resolving EDITOR returns null and resolving VSCode throws', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockResolvedValue(null)
+        .calledWith('code')
+        .mockRejectedValue(new Error('some error'));
+
+      expect(await determineEditor()).toBeNull();
+    });
+
+    it('returns null if resolving EDITOR throws and resolving VSCode returns null', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockRejectedValue(new Error('some error'))
+        .calledWith('code')
+        .mockResolvedValue(null);
+
+      expect(await determineEditor()).toBeNull();
+    });
+
+    it('returns null if resolving EDITOR throws and resolving VSCode throws', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: 'editor', TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('editor')
+        .mockRejectedValue(new Error('some error'))
+        .calledWith('code')
+        .mockRejectedValue(new Error('some error'));
+
+      expect(await determineEditor()).toBeNull();
+    });
+
+    it('returns null if EDITOR is unset and resolving VSCode returns null', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: undefined, TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('code')
+        .mockResolvedValue(null);
+
+      expect(await determineEditor()).toBeNull();
+    });
+
+    it('returns null if EDITOR is unset and resolving VSCode throws', async () => {
+      jest
+        .spyOn(envUtils, 'getEnvironmentVariables')
+        .mockReturnValue({ EDITOR: undefined, TODAY: undefined });
+      when(jest.spyOn(miscUtils, 'resolveExecutable'))
+        .calledWith('code')
+        .mockRejectedValue(new Error('some error'));
+
+      expect(await determineEditor()).toBeNull();
+    });
+  });
+});

src/editor-utils.ts

@@ -0,0 +1,56 @@
+import { getEnvironmentVariables } from './env-utils';
+import { debug, resolveExecutable } from './misc-utils';
+
+/**
+ * Information about the editor present on the user's computer.
+ *
+ * @property path - The path to the executable representing the editor.
+ * @property args - Command-line arguments to pass to the executable when
+ * calling it.
+ */
+export interface Editor {
+  path: string;
+  args: string[];
+}
+
+/**
+ * Looks for an executable that represents a code editor on your computer. Tries
+ * the `EDITOR` environment variable first, falling back to the executable that
+ * represents VSCode (`code`).
+ *
+ * @returns A promise that contains information about the found editor (path and
+ * arguments), or null otherwise.
+ */
+export async function determineEditor(): Promise<Editor | null> {
+  let executablePath: string | null = null;
+  const executableArgs: string[] = [];
+  const { EDITOR } = getEnvironmentVariables();
+
+  if (EDITOR !== undefined) {
+    try {
+      executablePath = await resolveExecutable(EDITOR);
+    } catch (error) {
+      debug(
+        `Could not resolve executable ${EDITOR} (${error}), falling back to VSCode`,
+      );
+    }
+  }
+
+  if (executablePath === null) {
+    try {
+      executablePath = await resolveExecutable('code');
+      // Waits until the file is closed before returning
+      executableArgs.push('--wait');
+    } catch (error) {
+      debug(
+        `Could not resolve path to VSCode: ${error}, continuing regardless`,
+      );
+    }
+  }
+
+  if (executablePath !== null) {
+    return { path: executablePath, args: executableArgs };
+  }
+
+  return null;
+}

src/env-utils.test.ts

@@ -0,0 +1,27 @@
+import { getEnvironmentVariables } from './env-utils';
+
+describe('env-utils', () => {
+  describe('getEnvironmentVariables', () => {
+    let existingProcessEnv: NodeJS.ProcessEnv;
+
+    beforeEach(() => {
+      existingProcessEnv = { ...process.env };
+    });
+
+    afterEach(() => {
+      Object.keys(existingProcessEnv).forEach((key) => {
+        process.env[key] = existingProcessEnv[key];
+      });
+    });
+
+    it('returns only the environment variables from process.env that we use in this tool', () => {
+      process.env.EDITOR = 'editor';
+      process.env.TODAY = 'today';
+
+      expect(getEnvironmentVariables()).toStrictEqual({
+        EDITOR: 'editor',
+        TODAY: 'today',
+      });
+    });
+  });
+});

src/env-utils.ts

@@ -0,0 +1,16 @@
+interface Env {
+  EDITOR: string | undefined;
+  TODAY: string | undefined;
+}
+
+/**
+ * Returns all of the environment variables that this tool uses.
+ *
+ * @returns An object with a selection of properties from `process.env` that
+ * this tool needs to access, whether their values are defined or not.
+ */
+export function getEnvironmentVariables(): Env {
+  return ['EDITOR', 'TODAY'].reduce((object, key) => {
+    return { ...object, [key]: process.env[key] };
+  }, {} as Env);
+}