feat: Added --watch-ignored new command line option

src/cmd/run.js

@@ -39,6 +39,7 @@ export type CmdRunParams = {|
   preInstall: boolean,
   sourceDir: string,
   watchFile?: string,
+  watchIgnored?: Array<string>,
   startUrl?: Array<string>,
   target?: Array<string>,
   args?: Array<string>,
@@ -84,6 +85,7 @@ export default async function run(
     preInstall = false,
     sourceDir,
     watchFile,
+    watchIgnored,
     startUrl,
     target,
     args,
@@ -248,6 +250,7 @@ export default async function run(
       extensionRunner,
       sourceDir,
       watchFile,
+      watchIgnored,
       artifactsDir,
       ignoreFiles,
       noInput,

src/extension-runners/index.js

@@ -240,6 +240,7 @@ export type WatcherCreatorParams = {|
   reloadExtension: (string) => void,
   sourceDir: string,
   watchFile?: string,
+  watchIgnored?: Array<string>,
   artifactsDir: string,
   onSourceChange?: OnSourceChangeFn,
   ignoreFiles?: Array<string>,
@@ -250,7 +251,8 @@ export type WatcherCreatorFn = (params: WatcherCreatorParams) => Watchpack;
 
 export function defaultWatcherCreator(
   {
-    reloadExtension, sourceDir, watchFile, artifactsDir, ignoreFiles,
+    reloadExtension, sourceDir, watchFile,
+    watchIgnored, artifactsDir, ignoreFiles,
     onSourceChange = defaultSourceWatcher,
     createFileFilter = defaultFileFilterCreator,
   }: WatcherCreatorParams
@@ -261,6 +263,7 @@ export function defaultWatcherCreator(
   return onSourceChange({
     sourceDir,
     watchFile,
+    watchIgnored,
     artifactsDir,
     onChange: () => reloadExtension(sourceDir),
     shouldWatchFile: (file) => fileFilter.wantFile(file),
@@ -274,6 +277,7 @@ export type ReloadStrategyParams = {|
   extensionRunner: IExtensionRunner,
   sourceDir: string,
   watchFile?: string,
+  watchIgnored?: Array<string>,
   artifactsDir: string,
   ignoreFiles?: Array<string>,
   noInput?: boolean,
@@ -293,6 +297,7 @@ export function defaultReloadStrategy(
     noInput = false,
     sourceDir,
     watchFile,
+    watchIgnored,
   }: ReloadStrategyParams,
   {
     createWatcher = defaultWatcherCreator,
@@ -311,6 +316,7 @@ export function defaultReloadStrategy(
     },
     sourceDir,
     watchFile,
+    watchIgnored,
     artifactsDir,
     ignoreFiles,
   });

src/program.js

@@ -616,11 +616,20 @@ Example: $0 --help run.
       },
       'watch-file': {
         describe: 'Reload the extension only when the contents of this' +
-                  'file changes. This is useful if you use a custom' +
+                  ' file changes. This is useful if you use a custom' +
                   ' build process for your extension',
         demandOption: false,
         type: 'string',
       },
+      'watch-ignored': {
+        describe: 'Paths and globs patterns that should not be ' +
+                  'watched for changes. This is useful if you want ' +
+                  'to explicitly prevent web-ext from watching part ' +
+                  'of the extension directory tree, ' +
+                  'e.g. the node_modules folder.',
+        demandOption: false,
+        type: 'array',
+      },
       'pre-install': {
         describe: 'Pre-install the extension into the profile before ' +
                   'startup. This is only needed to support older versions ' +

src/watcher.js

@@ -19,9 +19,11 @@ export type OnChangeFn = () => any;
 export type OnSourceChangeParams = {|
   sourceDir: string,
   watchFile?: string,
+  watchIgnored?: Array<string>,
   artifactsDir: string,
   onChange: OnChangeFn,
   shouldWatchFile: ShouldWatchFn,
+  debounceTime?: number,
 |};
 
 // NOTE: this fix an issue with flow and default exports (which currently
@@ -36,16 +38,20 @@ export default function onSourceChange(
   {
     sourceDir,
     watchFile,
+    watchIgnored,
     artifactsDir,
     onChange,
     shouldWatchFile,
+    debounceTime = 1000,
   }: OnSourceChangeParams
 ): Watchpack {
   // TODO: For network disks, we would need to add {poll: true}.
-  const watcher = new Watchpack();
+  const watcher = watchIgnored ?
+    new Watchpack({ignored: watchIgnored}) :
+    new Watchpack();
 
   const executeImmediately = true;
-  onChange = debounce(onChange, 1000, executeImmediately);
+  onChange = debounce(onChange, debounceTime, executeImmediately);
 
   watcher.on('change', (filePath) => {
     proxyFileChanges({artifactsDir, onChange, filePath, shouldWatchFile});

tests/functional/test.cli.run.js

@@ -14,18 +14,28 @@ const EXPECTED_MESSAGE = 'Fake Firefox binary executed correctly.';
 
 describe('web-ext run', () => {
 
-  it('accepts: --no-reload --watch-file --source-dir SRCDIR --firefox FXPATH',
+  it('accepts: --no-reload --watch-file --source-dir SRCDIR ' +
+    '--firefox FXPATH --watch-ignored',
      () => withTempAddonDir(
        {addonPath: minimalAddonPath},
        (srcDir) => {
          const watchedFile = path.join(srcDir, 'watchedFile.txt');
+         const watchIgnoredArr = ['ignoredFile1.txt', 'ignoredFile2.txt'].map(
+           (file) => path.join(srcDir, file)
+         );
+         const watchIgnoredFile = path.join(srcDir, 'ignoredFile3.txt');
+
          fs.writeFileSync(watchedFile, '');
+         watchIgnoredArr.forEach((file) => fs.writeFileSync(file, ''));
+         fs.writeFileSync(watchIgnoredFile, '');
 
          const argv = [
            'run', '--verbose', '--no-reload',
            '--source-dir', srcDir,
            '--watch-file', watchedFile,
            '--firefox', fakeFirefoxPath,
+           '--watch-ignored', ...watchIgnoredArr,
+           '--watch-ignored', watchIgnoredFile,
          ];
          const spawnOptions = {
            env: {

tests/unit/test-extension-runners/test.extension-runners.js

@@ -299,6 +299,7 @@ describe('util/extension-runners', () => {
         sourceDir: '/path/to/extension/source/',
         artifactsDir: '/path/to/web-ext-artifacts',
         watchFile: '/path/to/watched/file',
+        watchIgnored: '/path/to/ignored/file',
         onSourceChange: sinon.spy(() => {}),
         ignoreFiles: ['path/to/file', 'path/to/file2'],
         reloadExtension: sinon.spy(() => Promise.resolve()),
@@ -321,6 +322,7 @@ describe('util/extension-runners', () => {
         sinon.match({
           sourceDir: config.sourceDir,
           watchFile: config.watchFile,
+          watchIgnored: config.watchIgnored,
           artifactsDir: config.artifactsDir,
           onChange: sinon.match.typeOf('function'),
         })
@@ -391,6 +393,7 @@ describe('util/extension-runners', () => {
         extensionRunner,
         sourceDir: '/path/to/extension/source',
         watchFile: '/path/to/watched/file',
+        watchIgnored: '/path/to/ignored/file',
         artifactsDir: '/path/to/web-ext-artifacts/',
         ignoreFiles: ['first/file', 'second/file'],
       };
@@ -425,6 +428,7 @@ describe('util/extension-runners', () => {
         sinon.match({
           sourceDir: sentArgs.sourceDir,
           watchFile: sentArgs.watchFile,
+          watchIgnored: sentArgs.watchIgnored,
           artifactsDir: sentArgs.artifactsDir,
           ignoreFiles: sentArgs.ignoreFiles,
         })

tests/unit/test.program.js

@@ -561,6 +561,32 @@ describe('program.main', () => {
       });
   });
 
+  async function testWatchIgnoredOption(watchIgnored) {
+    const fakeCommands = fake(commands, {
+      run: () => Promise.resolve(),
+    });
+
+    await execProgram(
+      ['run', '--watch-ignored', ...watchIgnored],
+      {commands: fakeCommands});
+
+    sinon.assert.calledWithMatch(
+      execProgram,
+      fakeCommands.run,
+      {watchIgnored}
+    );
+  }
+
+  it('calls run with a single watchIgnored pattern', () => {
+    testWatchIgnoredOption(['path/to/fake/file1.txt']);
+  });
+
+  it('calls run with a multiple watchIgnored patterns', () => {
+    testWatchIgnoredOption(
+      ['path/to/fake/file1.txt', 'path/to/fake/pattern*']
+    );
+  });
+
   it('converts custom preferences into an object', () => {
     const fakeCommands = fake(commands, {
       run: () => Promise.resolve(),

tests/unit/test.watcher.js

@@ -6,6 +6,7 @@ import {it, describe} from 'mocha';
 import {fs} from 'mz';
 import sinon from 'sinon';
 import {assert} from 'chai';
+import Watchpack from 'watchpack';
 
 import {default as onSourceChange, proxyFileChanges} from '../../src/watcher';
 import {withTempDir} from '../../src/util/temp-dir';
@@ -206,4 +207,58 @@ describe('watcher', () => {
 
   });
 
+  describe('--watch-ignored is passed in', () => {
+    it('does not change if ignored file is touched', () =>
+      withTempDir(async (tmpDir) => {
+        const debounceTime = 10;
+        const onChange = sinon.spy();
+        const tmpPath = tmpDir.path();
+        const files = ['foo.txt', 'bar.txt', 'foobar.txt'].map(
+          (filePath) => path.join(tmpPath, filePath)
+        );
+
+        const watcher = onSourceChange({
+          sourceDir: tmpPath,
+          artifactsDir: path.join(tmpPath, 'web-ext-artifacts'),
+          onChange,
+          watchIgnored: ['foo.txt'].map(
+            (filePath) => path.join(tmpPath, filePath)
+          ),
+          shouldWatchFile: (filePath) => filePath !== tmpPath,
+          debounceTime,
+        });
+
+        const watchAll = new Watchpack();
+        watchAll.watch(files, [], 0);
+
+        async function waitDebounce() {
+          await new Promise((resolve) => setTimeout(resolve, debounceTime * 2));
+        }
+
+        async function assertOnChange(filePath, expectedCallCount) {
+          const promiseOnChanged = new Promise((resolve) => watchAll.once(
+            'change',
+            (f) => resolve(f))
+          );
+          await waitDebounce();
+          await fs.writeFile(filePath, '<content>');
+          assert.equal(filePath, await promiseOnChanged);
+          await waitDebounce();
+          sinon.assert.callCount(onChange, expectedCallCount);
+        }
+
+        // Verify foo.txt is being ignored.
+        await assertOnChange(files[0], 0);
+
+        // Verify that the other two files are not be ignored.
+        await assertOnChange(files[1], 1);
+        await assertOnChange(files[2], 2);
+
+        watcher.close();
+        watchAll.close();
+        // Leave watcher.close some time to complete its cleanup before withTempDir will remove the
+        // test directory.
+        await waitDebounce();
+      }));
+  });
 });