Merge pull request #258 from mrmlnc/ISSUE-257_fix_patterns_with_leading_dot

ISSUE-257: Fix problem with patterns with leading dot segment

Author: mrmlnc

src/providers/filters/deep.spec.ts

@@ -87,15 +87,24 @@ describe('Providers → Filters → Deep', () => {
 			});
 
 			it('should return `false` when an entry starts with "./" and does not match to the positive pattern', () => {
-				const filter = getFilter('.', ['non-root/directory'], []);
+				const filter = getFilter('.', ['non-root/*'], []);
 				const entry = tests.entry.builder().path('./root').directory().build();
 
 				const actual = filter(entry);
 
 				assert.ok(!actual);
 			});
 
-			it('should return `true` when the positive pattern does not match, but the `baseNameMatch` is enabled', () => {
+			it('should return `true` when an entry match to the positive pattern with leading dot', () => {
+				const filter = getFilter('.', ['./root/*'], []);
+				const entry = tests.entry.builder().path('./root').directory().build();
+
+				const actual = filter(entry);
+
+				assert.ok(actual);
+			});
+
+			it('should return `true` when the positive pattern does not match by level, but the `baseNameMatch` is enabled', () => {
 				const filter = getFilter('.', ['*'], [], { baseNameMatch: true });
 				const entry = tests.entry.builder().path('root/directory').directory().build();
 

src/providers/filters/deep.ts

@@ -34,11 +34,13 @@ export default class DeepFilter {
 			return false;
 		}
 
-		if (this._isSkippedByPositivePatterns(entry, matcher)) {
+		const filepath = utils.path.removeLeadingDotSegment(entry.path);
+
+		if (this._isSkippedByPositivePatterns(filepath, matcher)) {
 			return false;
 		}
 
-		return this._isSkippedByNegativePatterns(entry, negativeRe);
+		return this._isSkippedByNegativePatterns(filepath, negativeRe);
 	}
 
 	private _isSkippedByDeep(entryDepth: number): boolean {
@@ -56,11 +58,11 @@ export default class DeepFilter {
 		return entryPathDepth - (basePath === '' ? 0 : basePathDepth);
 	}
 
-	private _isSkippedByPositivePatterns(entry: Entry, matcher: PartialMatcher): boolean {
-		return !this._settings.baseNameMatch && !matcher.match(entry.path);
+	private _isSkippedByPositivePatterns(entryPath: string, matcher: PartialMatcher): boolean {
+		return !this._settings.baseNameMatch && !matcher.match(entryPath);
 	}
 
-	private _isSkippedByNegativePatterns(entry: Entry, negativeRe: PatternRe[]): boolean {
-		return !utils.pattern.matchAny(entry.path, negativeRe);
+	private _isSkippedByNegativePatterns(entryPath: string, negativeRe: PatternRe[]): boolean {
+		return !utils.pattern.matchAny(entryPath, negativeRe);
 	}
 }

src/providers/filters/entry.spec.ts

@@ -161,6 +161,15 @@ describe('Providers → Filters → Entry', () => {
 				assert.ok(!actual);
 			});
 
+			it('should return `true` when an entry match to the positive pattern with leading dot', () => {
+				const filter = getFilter(['./**/*'], []);
+				const entry = tests.entry.builder().path('./root/file.txt').file().build();
+
+				const actual = filter(entry);
+
+				assert.ok(actual);
+			});
+
 			it('should return `true` when an entry match to the positive pattern', () => {
 				const filter = getFilter(['**/*'], []);
 				const entry = tests.entry.builder().path('root/file.txt').file().build();

src/providers/filters/entry.ts

@@ -62,7 +62,9 @@ export default class EntryFilter {
 		return this._isMatchToPatterns(fullpath, negativeRe);
 	}
 
-	private _isMatchToPatterns(filepath: string, patternsRe: PatternRe[]): boolean {
+	private _isMatchToPatterns(entryPath: string, patternsRe: PatternRe[]): boolean {
+		const filepath = utils.path.removeLeadingDotSegment(entryPath);
+
 		return utils.pattern.matchAny(filepath, patternsRe);
 	}
 }

src/utils/path.spec.ts

@@ -54,4 +54,23 @@ describe('Utils → Path', () => {
 			assert.strictEqual(util.escape('abc@'), 'abc@');
 		});
 	});
+
+	describe('.removeLeadingDotCharacters', () => {
+		it('should return path without changes', () => {
+			assert.strictEqual(util.removeLeadingDotSegment('../a/b'), '../a/b');
+			assert.strictEqual(util.removeLeadingDotSegment('~/a/b'), '~/a/b');
+			assert.strictEqual(util.removeLeadingDotSegment('/a/b'), '/a/b');
+			assert.strictEqual(util.removeLeadingDotSegment('a/b'), 'a/b');
+
+			assert.strictEqual(util.removeLeadingDotSegment('..\\a\\b'), '..\\a\\b');
+			assert.strictEqual(util.removeLeadingDotSegment('~\\a\\b'), '~\\a\\b');
+			assert.strictEqual(util.removeLeadingDotSegment('\\a\\b'), '\\a\\b');
+			assert.strictEqual(util.removeLeadingDotSegment('a\\b'), 'a\\b');
+		});
+
+		it('should return path without leading dit characters', () => {
+			assert.strictEqual(util.removeLeadingDotSegment('./a/b'), 'a/b');
+			assert.strictEqual(util.removeLeadingDotSegment('.\\a\\b'), 'a\\b');
+		});
+	});
 });

src/utils/path.ts

@@ -2,6 +2,7 @@ import * as path from 'path';
 
 import { Pattern } from '../types';
 
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
 const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
 
 /**
@@ -18,3 +19,17 @@ export function makeAbsolute(cwd: string, filepath: string): string {
 export function escape(pattern: Pattern): Pattern {
 	return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
 }
+
+export function removeLeadingDotSegment(entry: string): string {
+	// We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+	// eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+	if (entry.charAt(0) === '.') {
+		const secondCharactery = entry.charAt(1);
+
+		if (secondCharactery === '/' || secondCharactery === '\\') {
+			return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+		}
+	}
+
+	return entry;
+}

src/utils/pattern.spec.ts

@@ -399,13 +399,5 @@ describe('Utils → Pattern', () => {
 
 			assert.ok(!actual);
 		});
-
-		it('should return true for path with leading slash', () => {
-			const pattern = util.makeRe('*.js', {});
-
-			const actual = util.matchAny('./test.js', [pattern]);
-
-			assert.ok(actual);
-		});
 	});
 });

src/utils/pattern.ts

@@ -127,7 +127,5 @@ export function convertPatternsToRe(patterns: Pattern[], options: MicromatchOpti
 }
 
 export function matchAny(entry: string, patternsRe: PatternRe[]): boolean {
-	const filepath = entry.replace(/^\.[/\\]/, '');
-
-	return patternsRe.some((patternRe) => patternRe.test(filepath));
+	return patternsRe.some((patternRe) => patternRe.test(entry));
 }