change handling of negated source patterns

Fixes #614. Allow negated source patterns to be specified without unsetting the
default negation patterns.

Allow source patterns to override the default negation patterns if they start
with one of the ignored directories.

Author: novemberborn

docs/recipes/watch-mode.md

@@ -59,7 +59,9 @@ In AVA there's a distinction between *source files* and *test files*. As you can
 
 By default AVA watches for changes to the test files, `package.json`, and any other `.js` files. It'll ignore files in [certain directories](https://github.com/novemberborn/ignore-by-default/blob/master/index.js) as provided by the [`ignore-by-default`] package.
 
-You can configure patterns for the source files using the [`--source` CLI flag] or in the `ava` section of your `package.json` file. Note that if you specify a negative pattern the directories from [`ignore-by-default`] will no longer be ignored, so you may want to repeat these in your config.
+You can configure patterns for the source files using the [`--source` CLI flag] or in the `ava` section of your `package.json` file.
+
+You can specify patterns to match files in the folders that would otherwise be ignored, e.g. use `node_modules/some-dependency/*.js` to specify all `.js` files in `node_modules/some-dependency` as a source, even though normally all files in `node_modules` are ignored. Note that you need to specify an exact directory; `{.bower_components,node_modules}/**/*.js` won't work.
 
 If your tests write to disk they may trigger the watcher to rerun your tests. If this occurs you will need to use the `--source` flag.
 

lib/watcher.js

@@ -26,6 +26,12 @@ function rethrowAsync(err) {
 	});
 }
 
+function getDefaultIgnorePatterns() {
+	return defaultIgnore.map(function (dir) {
+		return dir + '/**/*';
+	});
+}
+
 // Used on paths before they're passed to multimatch to Harmonize matching
 // across platforms.
 var matchable = process.platform === 'win32' ? slash : function (path) {
@@ -281,42 +287,51 @@ function getChokidarPatterns(files, sources) {
 		}
 	});
 
+	// Allow source patterns to override the default ignore patterns. Chokidar
+	// ignores paths that match the list of ignored patterns. It uses anymatch
+	// under the hood, which supports negation patterns. For any source pattern
+	// that starts with an ignored directory, ensure the corresponding negation
+	// pattern is added to the ignored paths.
+	var overrideDefaultIgnorePatterns = paths.filter(function (pattern) {
+		return defaultIgnore.indexOf(pattern.split('/')[0]) >= 0;
+	}).map(function (pattern) {
+		return '!' + pattern;
+	});
+	ignored = getDefaultIgnorePatterns().concat(ignored, overrideDefaultIgnorePatterns);
+
 	if (paths.length === 0) {
 		paths = ['package.json', '**/*.js'];
 	}
-
 	paths = paths.concat(files);
 
-	if (ignored.length === 0) {
-		ignored = defaultIgnore;
-	}
-
 	return {
 		paths: paths,
 		ignored: ignored
 	};
 }
 
 function makeSourceMatcher(sources) {
-	var patterns = sources;
+	var mixedPatterns = [];
+	var defaultIgnorePatterns = getDefaultIgnorePatterns();
+	var overrideDefaultIgnorePatterns = [];
 
-	var hasPositivePattern = patterns.some(function (pattern) {
-		return pattern[0] !== '!';
-	});
+	var hasPositivePattern = false;
+	sources.forEach(function (pattern) {
+		mixedPatterns.push(pattern);
+		if (!hasPositivePattern && pattern[0] !== '!') {
+			hasPositivePattern = true;
+		}
 
-	var hasNegativePattern = patterns.some(function (pattern) {
-		return pattern[0] === '!';
+		// Extract patterns that start with an ignored directory. These need to be
+		// rematched separately.
+		if (defaultIgnore.indexOf(pattern.split('/')[0]) >= 0) {
+			overrideDefaultIgnorePatterns.push(pattern);
+		}
 	});
 
 	// Same defaults as used for Chokidar.
 	if (!hasPositivePattern) {
-		patterns = ['package.json', '**/*.js'].concat(patterns);
-	}
-
-	if (!hasNegativePattern) {
-		patterns = patterns.concat(defaultIgnore.map(function (dir) {
-			return '!' + dir + '/**/*';
-		}));
+		mixedPatterns = ['package.json', '**/*.js'].concat(mixedPatterns);
 	}
 
 	return function (path) {
@@ -328,7 +343,22 @@ function makeSourceMatcher(sources) {
 			return false;
 		}
 
-		return multimatch(path, patterns).length === 1;
+		var isSource = multimatch(path, mixedPatterns).length === 1;
+		if (!isSource) {
+			return false;
+		}
+
+		var isIgnored = multimatch(path, defaultIgnorePatterns).length === 1;
+		if (!isIgnored) {
+			return true;
+		}
+
+		var isErroneouslyIgnored = multimatch(path, overrideDefaultIgnorePatterns).length === 1;
+		if (isErroneouslyIgnored) {
+			return true;
+		}
+
+		return false;
 	};
 }
 

test/watcher.js

@@ -158,7 +158,9 @@ group('chokidar is installed', function (beforeEach, test, group) {
 		t.same(chokidar.watch.firstCall.args, [
 			['package.json', '**/*.js'].concat(files),
 			{
-				ignored: defaultIgnore,
+				ignored: defaultIgnore.map(function (dir) {
+					return dir + '/**/*';
+				}),
 				ignoreInitial: true
 			}
 		]);
@@ -172,21 +174,25 @@ group('chokidar is installed', function (beforeEach, test, group) {
 		t.same(chokidar.watch.firstCall.args, [
 			['foo.js', 'baz.js'].concat(files),
 			{
-				ignored: ['bar.js', 'qux.js'],
+				ignored: defaultIgnore.map(function (dir) {
+					return dir + '/**/*';
+				}).concat('bar.js', 'qux.js'),
 				ignoreInitial: true
 			}
 		]);
 	});
 
-	test('default set of ignored files if configured sources does not contain exclusion patterns', function (t) {
+	test('configured sources can override default ignore patterns', function (t) {
 		t.plan(2);
-		start(['foo.js', 'baz.js']);
+		start(['node_modules/foo/*.js']);
 
 		t.ok(chokidar.watch.calledOnce);
 		t.same(chokidar.watch.firstCall.args, [
-			['foo.js', 'baz.js'].concat(files),
+			['node_modules/foo/*.js'].concat(files),
 			{
-				ignored: defaultIgnore,
+				ignored: defaultIgnore.map(function (dir) {
+					return dir + '/**/*';
+				}).concat('!node_modules/foo/*.js'),
 				ignoreInitial: true
 			}
 		]);
@@ -796,7 +802,7 @@ group('chokidar is installed', function (beforeEach, test, group) {
 			});
 		});
 
-		test('uses default patterns', function (t) {
+		test('uses default source patterns', function (t) {
 			t.plan(4);
 			seed();
 
@@ -821,16 +827,11 @@ group('chokidar is installed', function (beforeEach, test, group) {
 			});
 		});
 
-		test('uses default exclusion patterns if no exclusion pattern is given', function (t) {
+		test('uses default exclusion patterns', function (t) {
 			t.plan(2);
 
-			// Ensure each directory is treated as containing sources, but rely on
-			// the default exclusion patterns, also based on these directories, to
-			// exclude them again.
-			var sources = defaultIgnore.map(function (dir) {
-				return dir + '/**/*';
-			});
-			seed(sources);
+			// Ensure each directory is treated as containing sources.
+			seed(['**/*']);
 
 			// Synthesize an excluded file for each directory that's ignored by
 			// default. Apply deeper nesting for each file.
@@ -839,7 +840,7 @@ group('chokidar is installed', function (beforeEach, test, group) {
 				for (var i = index; i >= 0; i--) {
 					relPath = path.join(relPath, String(i));
 				}
-				return relPath;
+				return relPath + '.js';
 			});
 
 			// Ensure test/1.js also depends on the excluded files.
@@ -858,6 +859,20 @@ group('chokidar is installed', function (beforeEach, test, group) {
 			});
 		});
 
+		test('allows default exclusion patterns to be overriden', function (t) {
+			t.plan(2);
+			seed(['node_modules/foo/*.js']);
+
+			var dep = path.join('node_modules', 'foo', 'index.js');
+			emitDependencies(path.join('test', '1.js'), [path.resolve(dep)]);
+			change(dep);
+
+			return debounce(1).then(function () {
+				t.ok(api.run.calledTwice);
+				t.same(api.run.secondCall.args, [[path.join('test', '1.js')], {runOnlyExclusive: false}]);
+			});
+		});
+
 		test('ignores dependencies outside of the current working directory', function (t) {
 			t.plan(4);
 			seed(['**/*.js', '..foo.js']);