Pass watchedNodes to Watcher/WatcherAdapter

lib/builder.js

@@ -262,6 +262,12 @@ module.exports = class Builder extends EventEmitter {
     return nodeWrapper;
   }
 
+  get watchedSourceNodeWrappers() {
+    return this.nodeWrappers.filter(nw => {
+      return nw.nodeInfo.nodeType === 'source' && nw.nodeInfo.watched;
+    });
+  }
+
   checkInputPathsExist() {
     // We might consider checking this.unwatchedPaths as well.
     for (let i = 0; i < this.watchedPaths.length; i++) {

lib/cli.js

@@ -43,7 +43,11 @@ module.exports = function broccoliCLI(args) {
       const builder = getBuilder(options);
       const Watcher = getWatcher(options);
       const outputDir = options.outputPath;
-      const watcher = new Watcher(builder, buildWatcherOptions(options));
+      const watcher = new Watcher(
+        builder,
+        builder.watchedSourceNodeWrappers,
+        buildWatcherOptions(options)
+      );
 
       if (outputDir) {
         try {
@@ -112,7 +116,11 @@ module.exports = function broccoliCLI(args) {
       const builder = getBuilder(options);
       const Watcher = getWatcher(options);
       const outputTree = new TreeSync(builder.outputPath, outputDir);
-      const watcher = new Watcher(builder, buildWatcherOptions(options));
+      const watcher = new Watcher(
+        builder,
+        builder.watchedSourceNodeWrappers,
+        buildWatcherOptions(options)
+      );
 
       watcher.on('buildSuccess', () => {
         outputTree.sync();

lib/watcher.js

@@ -10,15 +10,15 @@ const logger = require('heimdalljs-logger')('broccoli:watcher');
 // principle.
 
 module.exports = class Watcher extends EventEmitter {
-  constructor(builder, options) {
+  constructor(builder, watchedNodes, options) {
     super();
     this.options = options || {};
     if (this.options.debounce == null) {
       this.options.debounce = 100;
     }
     this.builder = builder;
     this.watcherAdapter =
-      this.options.watcherAdapter || new WatcherAdapter(this.options.saneOptions);
+      this.options.watcherAdapter || new WatcherAdapter(watchedNodes, this.options.saneOptions);
     this.currentBuild = null;
     this._rebuildScheduled = false;
     this._ready = false;
@@ -41,11 +41,7 @@ module.exports = class Watcher extends EventEmitter {
     this.watcherAdapter.on('error', this._error.bind(this));
     this.currentBuild = Promise.resolve()
       .then(() => {
-        let watchedSourceNodes = this.builder.nodeWrappers.filter(nw => {
-          return nw.nodeInfo.nodeType === 'source' && nw.nodeInfo.watched;
-        });
-
-        return this.watcherAdapter.watch(watchedSourceNodes);
+        return this.watcherAdapter.watch();
       })
       .then(() => {
         logger.debug('ready');

lib/watcher_adapter.js

@@ -3,6 +3,7 @@
 const EventEmitter = require('events').EventEmitter;
 const sane = require('sane');
 const logger = require('heimdalljs-logger')('broccoli:watcherAdapter');
+const SourceNode = require('./wrappers/source-node');
 
 function defaultFilterFunction(name) {
   return /^[^.]/.test(name);
@@ -18,20 +19,29 @@ function bindFileEvent(adapter, watcher, node, event) {
 }
 
 module.exports = class WatcherAdapter extends EventEmitter {
-  constructor(options) {
+  constructor(watchedNodes, options) {
     super();
+    if (!Array.isArray(watchedNodes)) {
+      throw new TypeError(
+        `WatcherAdapter's first argument must be an array of SourceNodeWrapper nodes`
+      );
+    }
+    for (const node of watchedNodes) {
+      if (!(node instanceof SourceNode)) {
+        throw new Error(`${node} is not a SourceNode`);
+      }
+      if (node.nodeInfo.watched !== true) {
+        throw new Error(`${node.nodeInfo.sourceDirectory} it not watched`);
+      }
+    }
+    this.watchedNodes = watchedNodes;
     this.options = options || {};
     this.options.filter = this.options.filter || defaultFilterFunction;
     this.watchers = [];
   }
 
-  watch(watchedSourceNodes) {
-    if (!Array.isArray(watchedSourceNodes)) {
-      throw new TypeError(
-        `WatcherAdapter#watch's first argument must be an array of WatchedDir nodes`
-      );
-    }
-    let watchers = watchedSourceNodes.map(node => {
+  watch() {
+    let watchers = this.watchedNodes.map(node => {
       const watchedPath = node.nodeInfo.sourceDirectory;
       const watcher = new sane(watchedPath, this.options);
       this.watchers.push(watcher);

test/builder_test.js

@@ -389,6 +389,17 @@ describe('Builder', function() {
         /test\/fixtures\/basic\/foo\.txt: Not a directory/
       );
     });
+
+    it('returns only watched SourceNodeWrappers from watchedSourceNodeWrappers', function() {
+      const source1 = new broccoliSource.WatchedDir('test/fixtures/basic/');
+      const source2 = new broccoliSource.UnwatchedDir('test/fixtures/empty/');
+      builder = new Builder(new plugins.Merge([source1, source2]));
+
+      const watchedSourceNodeWrappers = builder.watchedSourceNodeWrappers;
+
+      expect(watchedSourceNodeWrappers).length.to.be(1);
+      expect(watchedSourceNodeWrappers[0].node).to.equal(source1);
+    });
   });
 
   describe('error handling in constructor', function() {

test/cli_test.js

@@ -48,6 +48,7 @@ describe('cli', function() {
       return cli(['node', 'broccoli', 'build', 'dist', '--watch']).then(() =>
         chai.expect(spy).to.have.been.calledWith(
           sinon.match.instanceOf(Builder),
+          sinon.match.array,
           sinon.match.has(
             'saneOptions',
             sinon.match({
@@ -140,6 +141,7 @@ describe('cli', function() {
           () =>
             chai.expect(spy).to.have.been.calledWith(
               sinon.match.instanceOf(Builder),
+              sinon.match.array,
               sinon.match.has(
                 'saneOptions',
                 sinon.match({
@@ -159,6 +161,7 @@ describe('cli', function() {
           () =>
             chai.expect(spy).to.have.been.calledWith(
               sinon.match.instanceOf(Builder),
+              sinon.match.array,
               sinon.match.has(
                 'saneOptions',
                 sinon.match({
@@ -176,6 +179,7 @@ describe('cli', function() {
         return cli(['node', 'broccoli', 'build', 'dist', '--watch', '--watcher', 'node']).then(() =>
           chai.expect(spy).to.have.been.calledWith(
             sinon.match.instanceOf(Builder),
+            sinon.match.array,
             sinon.match.has(
               'saneOptions',
               sinon.match({
@@ -332,6 +336,7 @@ describe('cli', function() {
       return cli(['node', 'broccoli', 'serve']).then(() =>
         chai.expect(spy).to.have.been.calledWith(
           sinon.match.instanceOf(Builder),
+          sinon.match.array,
           sinon.match.has(
             'saneOptions',
             sinon.match({
@@ -541,6 +546,7 @@ describe('cli', function() {
       return cli(['node', 'broccoli', 'serve', '--watcher', 'watchman']).then(() =>
         chai.expect(spy).to.have.been.calledWith(
           sinon.match.instanceOf(Builder),
+          sinon.match.array,
           sinon.match.has(
             'saneOptions',
             sinon.match({
@@ -559,6 +565,7 @@ describe('cli', function() {
       return cli(['node', 'broccoli', 'serve', '--watcher', 'node']).then(() =>
         chai.expect(spy).to.have.been.calledWith(
           sinon.match.instanceOf(Builder),
+          sinon.match.array,
           sinon.match.has(
             'saneOptions',
             sinon.match({
@@ -577,6 +584,7 @@ describe('cli', function() {
       return cli(['node', 'broccoli', 'serve', '--watcher', 'polling']).then(() =>
         chai.expect(spy).to.have.been.calledWith(
           sinon.match.instanceOf(Builder),
+          sinon.match.array,
           sinon.match.has(
             'saneOptions',
             sinon.match({
@@ -595,9 +603,9 @@ function createWatcherSpy() {
   const spy = sinon.spy();
   sinon.stub(broccoli, 'Watcher').value(
     class Watcher extends DummyWatcher {
-      constructor(builder, options) {
-        super(builder, options);
-        spy.call(null, builder, options);
+      constructor(builder, watchedSourceNodes, options) {
+        super(builder, watchedSourceNodes, options);
+        spy.call(null, builder, watchedSourceNodes, options);
       }
 
       start() {

test/watcher_adapter_test.js

@@ -1,6 +1,8 @@
 'use strict';
 
 const WatcherAdapter = require('../lib/watcher_adapter');
+const TransformNodeWrapper = require('../lib/wrappers/transform-node');
+const SourceNodeWrapper = require('../lib/wrappers/source-node');
 const bindFileEvent = WatcherAdapter.bindFileEvent;
 const fs = require('fs');
 const chai = require('chai');
@@ -14,6 +16,29 @@ describe('WatcherAdapter', function() {
     sinon.restore();
   });
 
+  const FIXTURE_BASIC = __dirname + '/fixtures/basic';
+  const FIXTURE_PROJECT = __dirname + '/fixtures/project';
+  const watchedNodeBasic = new SourceNodeWrapper();
+  watchedNodeBasic.nodeInfo = {
+    nodeType: 'source',
+    sourceDirectory: FIXTURE_BASIC,
+    watched: true,
+  };
+
+  const unwatchedNodeBasic = new SourceNodeWrapper();
+  unwatchedNodeBasic.nodeInfo = {
+    nodeType: 'source',
+    sourceDirectory: FIXTURE_BASIC,
+    watched: false,
+  };
+
+  const watchedNodeProject = new SourceNodeWrapper();
+  watchedNodeProject.nodeInfo = {
+    nodeType: 'source',
+    sourceDirectory: FIXTURE_PROJECT,
+    watched: true,
+  };
+
   describe('bindFileEvent', function() {
     const adapter = {
       emit() {},
@@ -71,15 +96,15 @@ describe('WatcherAdapter', function() {
     });
 
     it('has defaults', function() {
-      const adapter = new WatcherAdapter();
+      const adapter = new WatcherAdapter([]);
 
       expect(adapter.options).to.have.keys('filter');
       expect(adapter.options.filter).to.have.be.a('Function');
     });
 
     it('supports custom options, but without filter', function() {
       const customOptions = {};
-      const adapter = new WatcherAdapter(customOptions);
+      const adapter = new WatcherAdapter([], customOptions);
 
       expect(adapter.options).to.eql(customOptions);
       expect(adapter.options.filter).to.have.be.a('Function');
@@ -88,11 +113,45 @@ describe('WatcherAdapter', function() {
     it('supports custom options, and allows for a  custom filter', function() {
       function filter() {}
       const customOptions = { filter };
-      const adapter = new WatcherAdapter(customOptions);
+      const adapter = new WatcherAdapter([], customOptions);
 
       expect(adapter.options).to.eql(customOptions);
       expect(adapter.options.filter).to.eql(filter);
     });
+
+    it('throws if you try to watch a non array', function() {
+      expect(() => new WatcherAdapter()).to.throw(
+        TypeError,
+        `WatcherAdapter's first argument must be an array of SourceNodeWrapper nodes`
+      );
+
+      [null, undefined, NaN, {}, { length: 0 }, 'string', function() {}, Symbol('OMG')].forEach(
+        arg => {
+          expect(() => new WatcherAdapter(arg)).to.throw(
+            TypeError,
+            `WatcherAdapter's first argument must be an array of SourceNodeWrapper nodes`
+          );
+        }
+      );
+    });
+
+    it('throws if you try to watch a non node', function() {
+      expect(() => new WatcherAdapter([{}])).to.throw(Error, `[object Object] is not a SourceNode`);
+    });
+
+    it('throws if you try to watch a non-source node', function() {
+      expect(() => new WatcherAdapter([new TransformNodeWrapper()])).to.throw(
+        Error,
+        `[NodeWrapper:undefined undefined at undefined] is not a SourceNode`
+      );
+    });
+
+    it('throws if you try to watch a non-watchable node', function() {
+      expect(() => new WatcherAdapter([unwatchedNodeBasic])).to.throw(
+        Error,
+        `/Users/goli/Projects/broccoli/test/fixtures/basic it not watched`
+      );
+    });
   });
 
   describe('watch', function() {
@@ -103,58 +162,24 @@ describe('WatcherAdapter', function() {
     const FIXTURE_PROJECT = __dirname + (isWin ? '\\fixtures\\project' : '/fixtures/project');
     let adapter;
 
-    const watchedNodeBasic = {
-      revise() {},
-      nodeInfo: {
-        nodeType: 'source',
-        sourceDirectory: FIXTURE_BASIC,
-      },
-    };
-
-    const watchedNodeProject = {
-      revise() {},
-      nodeInfo: {
-        nodeType: 'source',
-        sourceDirectory: FIXTURE_PROJECT,
-      },
-    };
-
     afterEach(function() {
       adapter.quit();
     });
 
     it('supports symmetric start/shutdown', function() {
-      adapter = new WatcherAdapter();
-    });
-
-    it('throws if you try to watch a non array', function() {
-      adapter = new WatcherAdapter();
-
-      expect(() => adapter.watch()).to.throw(
-        TypeError,
-        `WatcherAdapter#watch's first argument must be an array of WatchedDir nodes`
-      );
-
-      [null, undefined, NaN, {}, { length: 0 }, 'string', function() {}, Symbol('OMG')].forEach(
-        arg => {
-          expect(() => adapter.watch(arg)).to.throw(
-            TypeError,
-            `WatcherAdapter#watch's first argument must be an array of WatchedDir nodes`
-          );
-        }
-      );
+      adapter = new WatcherAdapter([]);
     });
 
     it('actually works !!', function() {
-      adapter = new WatcherAdapter();
+      adapter = new WatcherAdapter([watchedNodeBasic]);
       const changeHandler = sinon.spy();
       adapter.on('change', changeHandler);
 
       expect(changeHandler).to.have.callCount(0);
 
       expect(adapter.watchers.length).to.eql(0);
 
-      let watching = adapter.watch([watchedNodeBasic]);
+      let watching = adapter.watch();
 
       expect(adapter.watchers.length).to.eql(1);