FIX (CodeAnalyzer): @W-16121713@: Allow project to live under .dot folders (#1530)

Author: stephen-carter-at-sf

src/lib/DefaultRuleManager.ts

@@ -74,7 +74,7 @@ export class DefaultRuleManager implements RuleManager {
 		return this.catalog.getRulesMatchingFilters(filters);
 	}
 
-	async runRulesMatchingCriteria(filters: RuleFilter[], targets: string[], runOptions: RunOptions, engineOptions: EngineOptions): Promise<Results> {
+	async runRulesMatchingCriteria(filters: RuleFilter[], targets: string[], runOptions: RunOptions, engineOptions: EngineOptions, projectDir?: string): Promise<Results> {
 		// Declare a variable that we can later use to store the engine results, as well as something to help us track
 		// which engines actually ran.
 		let ruleResults: RuleResult[] = [];
@@ -100,7 +100,7 @@ export class DefaultRuleManager implements RuleManager {
 			// them all in. Note that some engines (pmd) need groups while others (eslint) need the rules.
 			const engineGroups = ruleGroups.filter(g => g.engine === e.getName());
 			const engineRules = rules.filter(r => r.engine === e.getName());
-			const engineTargets = await this.unpackTargets(e, targets, matchedTargets);
+			const engineTargets = await this.unpackTargets(e, targets, matchedTargets, projectDir);
 			this.logger.trace(`For ${e.getName()}, found ${engineGroups.length} groups, ${engineRules.length} rules, ${engineTargets.length} targets`);
 
 			if (e.shouldEngineRun(engineGroups, engineRules, engineTargets, engineOptions)) {
@@ -247,7 +247,7 @@ export class DefaultRuleManager implements RuleManager {
 	 *
 	 * Any items from the 'targets' array that result in a match are added to the 'matchedTargets' Set.
 	 */
-	protected async unpackTargets(engine: RuleEngine, targets: string[], matchedTargets: Set<string>): Promise<RuleTarget[]> {
+	protected async unpackTargets(engine: RuleEngine, targets: string[], matchedTargets: Set<string>, projectDir?: string): Promise<RuleTarget[]> {
 		const ruleTargets: RuleTarget[] = [];
 		// Ask engines for their desired target patterns.
 		const engineTargets = await engine.getTargetPatterns();
@@ -283,7 +283,7 @@ export class DefaultRuleManager implements RuleManager {
 
 		// We want to use a path matcher that can filter based on the engine's target patterns and any negative globs
 		// provided to us.
-		const pm = new PathMatcher([...engineTargets, ...negativePatterns]);
+		const pm = new PathMatcher([...engineTargets, ...negativePatterns], projectDir);
 		for (const target of positivePatterns) {
 			// Used to detect if the target resulted in a match
 			const ruleTargetsInitialLength: number = ruleTargets.length;

src/lib/InputProcessor.ts

@@ -21,7 +21,7 @@ export interface InputProcessor {
 
 	resolveTargetPaths(inputs: Inputs): string[];
 
-	resolveProjectDirPaths(inputs: Inputs): string[];
+	resolveProjectDirPaths(inputs: Inputs, displayResolvedProjectDir?: boolean): string[];
 
 	createRunOptions(inputs: Inputs, isDfa: boolean): RunOptions;
 
@@ -45,7 +45,7 @@ export class InputProcessorImpl implements InputProcessor {
 		return (inputs.path as string[]).map(p => path.resolve(untildify(p)));
 	}
 
-	public resolveProjectDirPaths(inputs: Inputs): string[] {
+	public resolveProjectDirPaths(inputs: Inputs, displayResolvedProjectDir: boolean = true): string[] {
 		// If projectdir is provided, then return it since at this point it has already been validated to exist
 		if (inputs.projectdir && (inputs.projectdir as string[]).length > 0) {
 			return (inputs.projectdir as string[]).map(p => path.resolve(normalize(untildify(p))))
@@ -58,7 +58,9 @@ export class InputProcessorImpl implements InputProcessor {
 		const commonParentFolder = getFirstCommonParentFolder(this.getAllTargetFiles(inputs));
 		let projectFolder: string = findFolderThatContainsSfdxProjectFile(commonParentFolder);
 		projectFolder = projectFolder.length > 0 ? projectFolder : commonParentFolder
-		this.displayInfoOnlyOnce('info.resolvedProjectDir', [projectFolder])
+		if (displayResolvedProjectDir) {
+			this.displayInfoOnlyOnce('info.resolvedProjectDir', [projectFolder])
+		}
 		return [projectFolder];
 	}
 

src/lib/RuleManager.ts

@@ -29,5 +29,5 @@ export interface RuleManager {
 	/**
 	 * @param engineOptions - see RuleEngine#run
 	 */
-	runRulesMatchingCriteria(filters: RuleFilter[], target: string[], runOptions: RunOptions, engineOptions: EngineOptions): Promise<Results>;
+	runRulesMatchingCriteria(filters: RuleFilter[], target: string[], runOptions: RunOptions, engineOptions: EngineOptions, projectDir?: string): Promise<Results>;
 }

src/lib/actions/AbstractRunAction.ts

@@ -90,11 +90,13 @@ export abstract class AbstractRunAction implements Action {
 		const resultsProcessor: ResultsProcessor = this.resultsProcessorFactory.createResultsProcessor(
 			this.display, outputOptions, jsonReturnValueHolder);
 
+		const primaryProjectDir: string = this.inputProcessor.resolveProjectDirPaths(inputs, false)[0];
+
 		// TODO: Inject RuleManager as a dependency to improve testability by removing coupling to runtime implementation
 		const ruleManager: RuleManager = await Controller.createRuleManager();
 
 		try {
-			const results: Results = await ruleManager.runRulesMatchingCriteria(filters, targetPaths, runOptions, engineOptions);
+			const results: Results = await ruleManager.runRulesMatchingCriteria(filters, targetPaths, runOptions, engineOptions, primaryProjectDir);
 			this.logger.trace(`Processing output with format ${outputOptions.format}`);
 			await resultsProcessor.processResults(results);
 			return jsonReturnValueHolder.get();

src/lib/util/PathMatcher.ts

@@ -10,15 +10,17 @@ type SortedPatterns = {
 
 export class PathMatcher {
 	private readonly matcher: TargetMatchingFunction;
+	private readonly normalizedProjectDir: string;
 
 	/**
 	 *
 	 * @param {TargetPattern[]} patterns - An array of TargetPatterns against which paths can be compared. Patterns can
 	 *                                     be positive or negative strings (i.e. don't/do start with `!`), or objects
 	 *                                     describing complex patterns.
 	 */
-	constructor(patterns: TargetPattern[]) {
+	constructor(patterns: TargetPattern[], projectDir?: string) {
 		this.matcher = this.generateMatchingFunction(patterns);
+		this.normalizedProjectDir = normalize(projectDir || process.cwd());
 	}
 
 
@@ -29,8 +31,8 @@ export class PathMatcher {
 	private generateMatchingFunction(patterns: TargetPattern[]): TargetMatchingFunction {
 		const {inclusionPatterns, exclusionPatterns, advancedPatterns} = this.sortPatterns(patterns);
 
-		const inclusionMatcher = picomatch(inclusionPatterns);
-		const exclusionMatcher = picomatch(exclusionPatterns);
+		const inclusionMatcher = picomatch(inclusionPatterns, {dot: true});
+		const exclusionMatcher = picomatch(exclusionPatterns, {dot: true});
 		// Each of the advanced patterns generates its own matching function, which will be applied in sequence.
 		const advancedMatchers = advancedPatterns.map(ap => this.generateAdvancedMatcher(ap));
 
@@ -115,7 +117,7 @@ export class PathMatcher {
 	 * @returns {Promise<string[]>} - The subset of the target strings that match the provided patterns.
 	 */
 	public async filterPathsByPatterns(targets: string[]): Promise<string[]> {
-		const matchResults: boolean[] = await Promise.all(targets.map(t => this.matcher(normalize(t))));
+		const matchResults: boolean[] = await Promise.all(targets.map(t => this.pathMatchesPatterns(t)));
 
 		const filteredTargets: string[] = [];
 		matchResults.forEach((r: boolean, idx: number) => {
@@ -132,6 +134,19 @@ export class PathMatcher {
 	 * @returns {Promise<boolean>}
 	 */
 	public async pathMatchesPatterns(target: string): Promise<boolean> {
-		return this.matcher(normalize(target));
+		return (await this.matcher(normalize(target))) && !this.isDotFileOrIsInDotFolderUnderProjectDir(target);
+	}
+
+	/**
+	 * Returns true if the target is a .fileName or is in a .folder under the project directory
+	 * 	Note that we do not want to exclude typical files underneath the projectDir just because the projectDir is
+	 * 	underneath a dot folder (like .jenkins/projectFolder/...), so we had to add {dot: true} to the picomatch
+	 * 	above. But we still want to exclude dot files and dot folders underneath the projectDir.
+	 */
+	private isDotFileOrIsInDotFolderUnderProjectDir(target: string): boolean {
+		if (target.startsWith(this.normalizedProjectDir)) {
+			target = target.slice(this.normalizedProjectDir.length);
+		}
+		return target.includes('/.');
 	}
 }

test/lib/util/PathMatcher.test.ts

@@ -164,6 +164,34 @@ describe('PathMatcher', () => {
 				expect(results).to.not.include(targets[4], 'Path wrongly included');
 			});
 		});
+
+		describe('Hidden dot folders', () => {
+			it('When projectDir contains a .dotFolder then the files underneath it are not matched', async () => {
+				const pm: PathMatcher = new PathMatcher(['**/*.js', '/some/projectFolder/**/*.cls'], '/some/projectFolder');
+				const targets: string[] = [
+					'/some/projectFolder/subFolder/.dotFolder/a.js',
+					'/some/projectFolder/subFolder/nonDotFolder/b.js',
+					'/some/projectFolder/subFolder/.dotFolder/c.cls',
+					'/some/projectFolder/subFolder/nonDotFolder/d.cls'
+				];
+
+				const results: string[] = await pm.filterPathsByPatterns(targets);
+				expect(results).to.deep.equal([targets[1],targets[3]]);
+			});
+
+			it('When projectDir is under a .dotFolder then the projectDir is not excluded', async () => {
+				const pm: PathMatcher = new PathMatcher(['**/*.js', '/some/.dotFolder/projectFolder/**/*.cls'], '/some/.dotFolder/projectFolder');
+				const targets: string[] = [
+					'/some/.dotFolder/projectFolder/subFolder/.dotFolder/a.js',
+					'/some/.dotFolder/projectFolder/subFolder/nonDotFolder/b.js',
+					'/some/.dotFolder/projectFolder/subFolder/.dotFolder/c.cls',
+					'/some/.dotFolder/projectFolder/subFolder/nonDotFolder/d.cls'
+				];
+
+				const results: string[] = await pm.filterPathsByPatterns(targets);
+				expect(results).to.deep.equal([targets[1],targets[3]]);
+			});
+		});
 	});
 
 	describe('#pathMatchesPatterns()', () => {
@@ -263,6 +291,38 @@ describe('PathMatcher', () => {
 			it('DOES NOT MATCH paths matching negative patterns but not positive patterns', async () => {
 				expect(await pm.pathMatchesPatterns(targets[4])).to.equal(false, 'Path wrongly not matched.');
 			});
-		})
-	})
+		});
+
+		describe('Hidden dot folders', () => {
+			it('When projectDir contains a .dotFolder then the files underneath it are not matched', async () => {
+				const pm: PathMatcher = new PathMatcher(['**/*.js', '/some/projectFolder/**/*.cls'], '/some/projectFolder');
+				const targets: string[] = [
+					'/some/projectFolder/subFolder/.dotFolder/a.js',
+					'/some/projectFolder/subFolder/nonDotFolder/b.js',
+					'/some/projectFolder/subFolder/.dotFolder/c.cls',
+					'/some/projectFolder/subFolder/nonDotFolder/d.cls'
+				];
+
+				expect(await pm.pathMatchesPatterns(targets[0])).to.equal(false);
+				expect(await pm.pathMatchesPatterns(targets[1])).to.equal(true);
+				expect(await pm.pathMatchesPatterns(targets[2])).to.equal(false);
+				expect(await pm.pathMatchesPatterns(targets[3])).to.equal(true);
+			});
+
+			it('When projectDir is under a .dotFolder then the projectDir is not excluded', async () => {
+				const pm: PathMatcher = new PathMatcher(['**/*.js', '/some/.dotFolder/projectFolder/**/*.cls'], '/some/.dotFolder/projectFolder/');
+				const targets: string[] = [
+					'/some/.dotFolder/projectFolder/.dotFolder/a.js',
+					'/some/.dotFolder/projectFolder/nonDotFolder/b.js',
+					'/some/.dotFolder/projectFolder/.dotFolder/c.cls',
+					'/some/.dotFolder/projectFolder/nonDotFolder/d.cls'
+				];
+
+				expect(await pm.pathMatchesPatterns(targets[0])).to.equal(false);
+				expect(await pm.pathMatchesPatterns(targets[1])).to.equal(true);
+				expect(await pm.pathMatchesPatterns(targets[2])).to.equal(false);
+				expect(await pm.pathMatchesPatterns(targets[3])).to.equal(true);
+			});
+		});
+	});
 });