feat: Added reload from the terminal by pressing a key (#746)

Author: saintsebastian

src/cmd/run.js

@@ -1,4 +1,7 @@
 /* @flow */
+import readline from 'readline';
+import tty from 'tty';
+
 import type FirefoxProfile from 'firefox-profile';
 import type Watchpack from 'watchpack';
 
@@ -41,18 +44,17 @@ export type WatcherCreatorParams = {|
   sourceDir: string,
   artifactsDir: string,
   onSourceChange?: OnSourceChangeFn,
-  desktopNotifications?: typeof defaultDesktopNotifications,
   ignoreFiles?: Array<string>,
   createFileFilter?: FileFilterCreatorFn,
+  addonReload: typeof defaultAddonReload,
 |};
 
 export type WatcherCreatorFn = (params: WatcherCreatorParams) => Watchpack;
 
 export function defaultWatcherCreator(
   {
-    addonId, client, sourceDir, artifactsDir, ignoreFiles,
+    addonId, addonReload, client, sourceDir, artifactsDir, ignoreFiles,
     onSourceChange = defaultSourceWatcher,
-    desktopNotifications = defaultDesktopNotifications,
     createFileFilter = defaultFileFilterCreator,
   }: WatcherCreatorParams
  ): Watchpack {
@@ -62,24 +64,37 @@ export function defaultWatcherCreator(
   return onSourceChange({
     sourceDir,
     artifactsDir,
-    onChange: () => {
-      log.debug(`Reloading add-on ID ${addonId}`);
-
-      return client.reloadAddon(addonId)
-        .catch((error) => {
-          log.error('\n');
-          log.error(error.stack);
-          desktopNotifications({
-            title: 'web-ext run: error occurred',
-            message: error.message,
-          });
-          throw error;
-        });
-    },
+    onChange: () => addonReload({addonId, client}),
     shouldWatchFile: (file) => fileFilter.wantFile(file),
   });
 }
 
+export type ReloadParams = {|
+  addonId: string,
+  client: RemoteFirefox,
+  desktopNotifications?: typeof defaultDesktopNotifications,
+|};
+
+export async function defaultAddonReload(
+  {
+    addonId, client,
+    desktopNotifications = defaultDesktopNotifications,
+  }: ReloadParams
+): Promise<void> {
+  log.debug(`Reloading add-on ID ${addonId}`);
+  try {
+    await client.reloadAddon(addonId);
+  } catch (reloadError) {
+    log.error('\n');
+    log.error(reloadError.stack);
+    desktopNotifications({
+      title: 'web-ext run: error occurred',
+      message: reloadError.message,
+    });
+    throw reloadError;
+  }
+}
+
 
 // defaultReloadStrategy types and implementation.
 
@@ -94,8 +109,10 @@ export type ReloadStrategyParams = {|
 |};
 
 export type ReloadStrategyOptions = {|
+  addonReload?: typeof defaultAddonReload,
   createWatcher?: WatcherCreatorFn,
   createFileFilter?: FileFilterCreatorFn,
+  stdin: stream$Readable,
 |};
 
 export function defaultReloadStrategy(
@@ -104,18 +121,50 @@ export function defaultReloadStrategy(
     sourceDir, artifactsDir, ignoreFiles,
   }: ReloadStrategyParams,
   {
+    addonReload = defaultAddonReload,
     createWatcher = defaultWatcherCreator,
+    stdin = process.stdin,
   }: ReloadStrategyOptions = {}
 ): void {
-  const watcher: Watchpack = (
-    createWatcher({addonId, client, sourceDir, artifactsDir, ignoreFiles})
-  );
+  const watcher: Watchpack = createWatcher({
+    addonId, addonReload, client, sourceDir, artifactsDir, ignoreFiles,
+  });
 
   firefoxProcess.on('close', () => {
     client.disconnect();
     watcher.close();
+    stdin.pause();
   });
 
+  if (stdin.isTTY && stdin instanceof tty.ReadStream) {
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+
+    // NOTE: this `Promise.resolve().then(...)` is basically used to spawn a "co-routine" that is executed
+    // before the callback attached to the Promise returned by this function (and it allows the `run` function
+    // to not be stuck in the while loop).
+    Promise.resolve().then(async function() {
+      log.info('Press R to reload (and Ctrl-C to quit)');
+
+      let userExit = false;
+
+      while (!userExit) {
+        const keyPressed = await new Promise((resolve) => {
+          stdin.once('keypress', (str, key) => resolve(key));
+        });
+
+        if (keyPressed.ctrl && keyPressed.name === 'c') {
+          userExit = true;
+        } else if (keyPressed.name === 'r' && addonId) {
+          log.debug('Reloading extension on user request');
+          await addonReload({addonId, client});
+        }
+      }
+
+      log.info('\nExiting web-ext on user request');
+      firefoxProcess.kill();
+    });
+  }
 }
 
 
@@ -186,6 +235,7 @@ export type CmdRunOptions = {|
   firefoxApp: typeof defaultFirefoxApp,
   firefoxClient: typeof defaultFirefoxClient,
   reloadStrategy: typeof defaultReloadStrategy,
+  ExtensionRunnerClass?: typeof ExtensionRunner,
 |};
 
 export default async function run(
@@ -198,6 +248,7 @@ export default async function run(
     firefoxApp = defaultFirefoxApp,
     firefoxClient = defaultFirefoxClient,
     reloadStrategy = defaultReloadStrategy,
+    ExtensionRunnerClass = ExtensionRunner,
   }: CmdRunOptions = {}): Promise<Object> {
 
   log.info(`Running web extension from ${sourceDir}`);
@@ -216,7 +267,7 @@ export default async function run(
 
   const manifestData = await getValidatedManifest(sourceDir);
 
-  const runner = new ExtensionRunner({
+  const runner = new ExtensionRunnerClass({
     sourceDir,
     firefoxApp,
     firefox,

src/firefox/index.js

@@ -96,6 +96,7 @@ export type FirefoxRunnerParams = {|
 export interface FirefoxProcess extends events$EventEmitter {
   stderr: events$EventEmitter;
   stdout: events$EventEmitter;
+  kill: Function;
 }
 
 export type FirefoxRunnerResults = {|

tests/unit/helpers.js

@@ -149,7 +149,9 @@ export function makeSureItFails(): Function {
  *
  */
  // $FLOW_IGNORE: fake can return any kind of object and fake a defined set of methods for testing.
-export function fake<T>(original: Object, methods: Object = {}): T {
+export function fake<T>(
+  original: Object, methods: Object = {}, skipProperties: Array<string> = []
+): T {
   var stub = {};
 
   // Provide stubs for all original members:
@@ -162,7 +164,8 @@ export function fake<T>(original: Object, methods: Object = {}): T {
 
   var proto = Object.getPrototypeOf(original);
   for (const key of props) {
-    if (!original.hasOwnProperty(key) && !proto.hasOwnProperty(key)) {
+    if (skipProperties.indexOf(key) >= 0 ||
+       (!original.hasOwnProperty(key) && !proto.hasOwnProperty(key))) {
       continue;
     }
     const definition = original[key] || proto[key];
@@ -190,6 +193,10 @@ export function fake<T>(original: Object, methods: Object = {}): T {
   return stub;
 }
 
+export function createFakeProcess() {
+  return fake(process, {}, ['EventEmitter', 'stdin']);
+}
+
 
 /*
  * Returns a fake Firefox client as would be returned by