fix: isFileIgnored should call isDirectoryIgnored

In order to determine if a file should be ignored, we also need to check
if the directory is ignored first.

To be more consistent with previous behavior, this also now returns
true from isDirectoryIgnored when a directory is outside of the
basepath.

src/config-array.js

@@ -643,11 +643,20 @@ export class ConfigArray extends Array {
 
 		// next check to see if the file should be ignored
 
+		// check if this should be ignored due to its directory
+		if (this.isDirectoryIgnored(path.dirname(filePath))) {
+			debug(`Ignoring ${filePath} based on directory pattern`);
+
+			// cache and return result - finalConfig is undefined at this point
+			cache.set(filePath, finalConfig);
+			return finalConfig;
+		}
+
 		// TODO: Maybe move elsewhere?
 		const relativeFilePath = path.relative(this.basePath, filePath);
 
 		if (shouldIgnoreFilePath(this.ignores, filePath, relativeFilePath)) {
-			debug(`Ignoring ${filePath}`);
+			debug(`Ignoring ${filePath} based on file pattern`);
 
 			// cache and return result - finalConfig is undefined at this point
 			cache.set(filePath, finalConfig);
@@ -736,17 +745,17 @@ export class ConfigArray extends Array {
 	 * while a pattern such as `/foo/**` is not considered to ignore the
 	 * directory because it is matching files.
 	 * @param {string} directoryPath The complete path of a directory to check.
-	 * @returns {boolean} True if the directory is ignored, false if not.
+	 * @returns {boolean} True if the directory is ignored, false if not. Will
+	 * 		return true for any directory that is not inside of `basePath`.
 	 * @throws {Error} When the `ConfigArray` is not normalized.
-	 * @throws {Error} When `directoryPath` is outside of `basePath`.
 	 */
 	isDirectoryIgnored(directoryPath) {
 
 		assertNormalized(this);
 
 		const relativeDirectoryPath = path.relative(this.basePath, directoryPath) + "/";
 		if (relativeDirectoryPath.startsWith("..")) {
-			throw new Error(`Directory ${directoryPath} is outside of the basePath ${this.basePath}`);
+			return true;
 		}
 
 		// first check the cache

tests/config-array.test.js

@@ -917,6 +917,23 @@ describe('ConfigArray', () => {
 				expect(configs.isFileIgnored(path.join(basePath, 'foo.test.js'))).to.be.false;
 			});
 
+			it('should return false when file is inside of ignored directory', () => {
+				configs = new ConfigArray([
+					{
+						ignores: ['ignoreme']
+					},
+					{
+						files: ['**/*.js']
+					}
+				], {
+					basePath
+				});
+
+				configs.normalizeSync();
+
+				expect(configs.isFileIgnored(path.join(basePath, 'ignoreme/foo.js'))).to.be.true;
+			});
+
 		});
 
 		describe("isDirectoryIgnored()", () => {
@@ -1059,7 +1076,7 @@ describe('ConfigArray', () => {
 				}).throws(/normalized/);
 			});
 
-			it("should throw an error when the directory is outside of the basePath", () => {
+			it("should return true when the directory is outside of the basePath", () => {
 				configs = new ConfigArray([
 					{
 						ignores: ['foo/bar']
@@ -1070,9 +1087,7 @@ describe('ConfigArray', () => {
 
 				configs.normalizeSync();
 
-				expect(() => {
-					configs.isDirectoryIgnored("/usr/fake/foo/bar");
-				}).throws(/outside/);
+				expect(configs.isDirectoryIgnored(path.resolve(basePath, '../foo/bar'))).to.be.true;
 			});
 
 		});