instrumentor: simplify checks for activating babel transformations

Author: kyakdan

package-lock.json

@@ -24,45 +24,49 @@ import { sourceCodeCoverage } from "./plugins/sourceCodeCoverage";
 describe("shouldInstrument check", () => {
 	it("should consider includes and excludes", () => {
 		const instrumentor = new Instrumentor(["include"], ["exclude"]);
-		expect(instrumentor.shouldInstrument("include")).toBeTruthy();
-		expect(instrumentor.shouldInstrument("exclude")).toBeFalsy();
+		expect(instrumentor.shouldInstrumentForFuzzing("include")).toBeTruthy();
+		expect(instrumentor.shouldInstrumentForFuzzing("exclude")).toBeFalsy();
 		expect(
-			instrumentor.shouldInstrument("/some/package/include/files")
+			instrumentor.shouldInstrumentForFuzzing("/some/package/include/files")
 		).toBeTruthy();
 		expect(
-			instrumentor.shouldInstrument("/some/package/exclude/files")
+			instrumentor.shouldInstrumentForFuzzing("/some/package/exclude/files")
+		).toBeFalsy();
+		expect(
+			instrumentor.shouldInstrumentForFuzzing("/something/else")
 		).toBeFalsy();
-		expect(instrumentor.shouldInstrument("/something/else")).toBeFalsy();
 	});
 
 	it("should include everything with *", () => {
 		const instrumentor = new Instrumentor(["*"], []);
-		expect(instrumentor.shouldInstrument("include")).toBeTruthy();
-		expect(instrumentor.shouldInstrument("/something/else")).toBeTruthy();
+		expect(instrumentor.shouldInstrumentForFuzzing("include")).toBeTruthy();
+		expect(
+			instrumentor.shouldInstrumentForFuzzing("/something/else")
+		).toBeTruthy();
 	});
 
 	it("should include nothing with emtpy string", () => {
 		const instrumentorWithEmptyInclude = new Instrumentor(["include", ""], []);
 		expect(
-			instrumentorWithEmptyInclude.shouldInstrument("include")
+			instrumentorWithEmptyInclude.shouldInstrumentForFuzzing("include")
 		).toBeTruthy();
 		expect(
-			instrumentorWithEmptyInclude.shouldInstrument("/something/else")
+			instrumentorWithEmptyInclude.shouldInstrumentForFuzzing("/something/else")
 		).toBeFalsy();
 
 		const instrumentorWithEmptyExclude = new Instrumentor(["include"], [""]);
 		expect(
-			instrumentorWithEmptyExclude.shouldInstrument("include")
+			instrumentorWithEmptyExclude.shouldInstrumentForFuzzing("include")
 		).toBeTruthy();
 		expect(
-			instrumentorWithEmptyExclude.shouldInstrument("/something/else")
+			instrumentorWithEmptyExclude.shouldInstrumentForFuzzing("/something/else")
 		).toBeFalsy();
 	});
 
 	it("should exclude with precedence", () => {
 		const instrumentor = new Instrumentor(["include"], ["*"]);
 		expect(
-			instrumentor.shouldInstrument("/some/package/include/files")
+			instrumentor.shouldInstrumentForFuzzing("/some/package/include/files")
 		).toBeFalsy();
 	});
 });

packages/instrumentor/instrument.test.ts

@@ -47,8 +47,8 @@ export class Instrumentor {
 		private readonly includes: string[] = ["*"],
 		private readonly excludes: string[] = ["node_modules"],
 		private readonly customHooks: string[] = [],
-		private readonly collectSourceCodeCoverage = false,
-		private readonly dryRun = false,
+		private readonly shouldCollectSourceCodeCoverage = false,
+		private readonly isDryRun = false,
 		private readonly idStrategy: EdgeIdStrategy = new MemorySyncIdStrategy()
 	) {}
 
@@ -62,7 +62,7 @@ export class Instrumentor {
 	instrument(code: string, filename: string): string {
 		const transformations: PluginItem[] = [];
 
-		const shouldInstrumentFile = this.shouldInstrument(filename);
+		const shouldInstrumentFile = this.shouldInstrumentForFuzzing(filename);
 
 		if (shouldInstrumentFile) {
 			transformations.push(codeCoverage(this.idStrategy), compareHooks);
@@ -72,14 +72,14 @@ export class Instrumentor {
 			transformations.push(functionHooks(filename));
 		}
 
-		if (shouldInstrumentFile) {
-			this.idStrategy.startForSourceFile(filename);
-		}
-
 		if (this.shouldCollectCodeCoverage(filename)) {
 			transformations.push(sourceCodeCoverage(filename));
 		}
 
+		if (shouldInstrumentFile) {
+			this.idStrategy.startForSourceFile(filename);
+		}
+
 		const transformedCode =
 			this.transform(filename, code, transformations)?.code || code;
 
@@ -156,17 +156,28 @@ export class Instrumentor {
 			delete require.cache[require.resolve(module)];
 		});
 	}
-	shouldInstrument(
+	shouldInstrumentForFuzzing(filepath: string): boolean {
+		return (
+			!this.isDryRun &&
+			Instrumentor.doesMatchFilters(filepath, this.includes, this.excludes)
+		);
+	}
+
+	private shouldCollectCodeCoverage(filepath: string): boolean {
+		return (
+			this.shouldCollectSourceCodeCoverage &&
+			(Instrumentor.doesMatchFilters(filepath, this.includes, this.excludes) ||
+				Instrumentor.doesMatchFilters(filepath, this.customHooks, ["nothing"]))
+		);
+	}
+
+	private static doesMatchFilters(
 		filepath: string,
-		dryRun = this.dryRun,
-		includes = this.includes,
-		excludes = this.excludes
+		includes: string[],
+		excludes: string[]
 	): boolean {
-		if (dryRun) {
-			return false;
-		}
-		const cleanedIncludes = this.cleanup(includes);
-		const cleanedExcludes = this.cleanup(excludes);
+		const cleanedIncludes = Instrumentor.cleanup(includes);
+		const cleanedExcludes = Instrumentor.cleanup(excludes);
 		const included =
 			cleanedIncludes.find((include) => filepath.includes(include)) !==
 			undefined;
@@ -176,20 +187,7 @@ export class Instrumentor {
 		return included && !excluded;
 	}
 
-	shouldCollectCodeCoverage(filepath: string): boolean {
-		const shouldCoverCustomHooks = this.shouldInstrument(
-			filepath,
-			false,
-			this.customHooks,
-			["nothing"]
-		);
-		return (
-			this.collectSourceCodeCoverage &&
-			(shouldCoverCustomHooks || this.shouldInstrument(filepath, false))
-		);
-	}
-
-	cleanup(settings: string[]): string[] {
+	private static cleanup(settings: string[]): string[] {
 		return settings
 			.filter((setting) => setting)
 			.map((setting) => (setting === "*" ? "" : setting)); // empty string matches every file