Merge pull request broccolijs#474 from ef4/absolute-ignore

Author: rwjblue

lib/watcher.ts

@@ -11,6 +11,10 @@ interface WatcherOptions {
   debounce?: number;
   watcherAdapter?: WatcherAdapter;
   saneOptions?: sane.Options;
+
+  // list of absolute paths that we should not watch, even if they end up nested
+  // beneath dirs that we are watching.
+  ignored?: string[];
 }
 
 // This Watcher handles all the Broccoli logic, such as debouncing. The
@@ -43,7 +47,8 @@ class Watcher extends EventEmitter {
     this._currentBuild = Promise.resolve();
     this.builder = builder;
     this.watcherAdapter =
-      this.options.watcherAdapter || new WatcherAdapter(watchedNodes, this.options.saneOptions);
+      this.options.watcherAdapter ||
+      new WatcherAdapter(watchedNodes, this.options.saneOptions, this.options.ignored);
 
     this._rebuildScheduled = false;
     this._ready = false;

lib/watcher_adapter.ts

@@ -4,15 +4,21 @@ import SourceNode from './wrappers/source-node';
 import SourceNodeWrapper from './wrappers/source-node';
 import bindFileEvent from './utils/bind-file-event';
 import HeimdallLogger from 'heimdalljs-logger';
+import { isAbsolute, relative } from 'path';
 
 const logger = new HeimdallLogger('broccoli:watcherAdapter');
 
 class WatcherAdapter extends EventEmitter {
   watchers: sane.Watcher[];
   watchedNodes: SourceNodeWrapper[];
   options: sane.Options;
+  private ignored: string[] | undefined;
 
-  constructor(watchedNodes: SourceNodeWrapper[], options: sane.Options = {}) {
+  constructor(
+    watchedNodes: SourceNodeWrapper[],
+    options: sane.Options = {},
+    ignored: string[] | undefined = undefined
+  ) {
     super();
     if (!Array.isArray(watchedNodes)) {
       throw new TypeError(
@@ -29,13 +35,14 @@ class WatcherAdapter extends EventEmitter {
     }
     this.watchedNodes = watchedNodes;
     this.options = options;
+    this.ignored = ignored;
     this.watchers = [];
   }
 
   watch() {
     const watchers = this.watchedNodes.map((node: SourceNodeWrapper) => {
       const watchedPath = node.nodeInfo.sourceDirectory;
-      const watcher = sane(watchedPath, this.options);
+      const watcher = sane(watchedPath, this.optionsFor(watchedPath));
       this.watchers.push(watcher);
       bindFileEvent(this, watcher, node, 'change');
       bindFileEvent(this, watcher, node, 'add');
@@ -73,6 +80,26 @@ class WatcherAdapter extends EventEmitter {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     return Promise.all(closing).then(() => {});
   }
+
+  private optionsFor(watchedPath: string): sane.Options {
+    let options = this.options;
+    if (this.ignored) {
+      // we need to convert any absolute ignored paths to local paths that sit
+      // within the watchedPath
+      const localIgnored = this.ignored
+        .map(ignoredAbsPath => {
+          const ignoredRelativePath = relative(watchedPath, ignoredAbsPath);
+          if (!ignoredRelativePath.startsWith('..') && !isAbsolute(ignoredRelativePath)) {
+            return ignoredRelativePath + '/**';
+          }
+        })
+        .filter(Boolean) as string[];
+      if (localIgnored.length > 0) {
+        options = Object.assign({}, options, { ignored: localIgnored });
+      }
+    }
+    return options;
+  }
 }
 
 export = WatcherAdapter;

test/watcher_adapter_test.js

@@ -6,6 +6,7 @@ import TransformNodeWrapper from '../lib/wrappers/transform-node';
 import SourceNodeWrapper from '../lib/wrappers/source-node';
 import WatcherAdapter from '../lib/watcher_adapter';
 import bindFileEvent from '../lib/utils/bind-file-event';
+import { join } from 'path';
 
 const expect = chai.expect;
 chai.use(sinonChai);
@@ -234,4 +235,25 @@ describe('WatcherAdapter', function() {
       });
     });
   });
+  describe('optionsFor', function() {
+    let adapter;
+    beforeEach(function() {
+      adapter = new WatcherAdapter([], {}, [join(__dirname, 'my-ignored-subdir')]);
+    });
+    afterEach(async function() {
+      await adapter.quit();
+    });
+    it('generates a relative ignored path inside watchedDir', function() {
+      const options = adapter.optionsFor(__dirname);
+      expect(options.ignored).to.deep.eq(['my-ignored-subdir/**']);
+    });
+    it('generates no relative ignored paths when they are outside watchedDir', function() {
+      const options = adapter.optionsFor('/somewhere/else');
+      expect(options.ignored).to.eq(undefined);
+    });
+    it('is not fooled by name prefix matches', function() {
+      const options = adapter.optionsFor(join(__dirname, 'my-ignored-subdir-just-kidding'));
+      expect(options.ignored).to.eq(undefined);
+    });
+  });
 });