Merge pull request #464 from mrmlnc/3.3.3

3.3.3

Author: mrmlnc

.eslintrc.json

@@ -2,7 +2,9 @@
 	"extends": "mrmlnc",
 	"rules": {
 		"no-magic-numbers": "off",
-		"@typescript-eslint/no-magic-numbers": "off"
+		"@typescript-eslint/no-magic-numbers": "off",
+		"import/namespace": "off",
+		"import/no-deprecated": "off"
 	},
 	"overrides": [
 		{

README.md

@@ -394,7 +394,7 @@ Indicates whether to traverse descendants of symbolic link directories when expa
 * Type: `FileSystemAdapter`
 * Default: `fs.*`
 
-Custom implementation of methods for working with the file system.
+Custom implementation of methods for working with the file system. Supports objects with enumerable properties only.
 
 ```ts
 export interface FileSystemAdapter {

__snapshots__/absolute.e2e.js

@@ -351,3 +351,15 @@ exports['Options Absolute (cwd & ignore) {"pattern":"**","options":{"ignore":["<
 exports['Options Absolute (cwd & ignore) {"pattern":"**","options":{"ignore":["<root>/fixtures/**"],"cwd":"fixtures","absolute":true}} (async) 1'] = []
 
 exports['Options Absolute (cwd & ignore) {"pattern":"**","options":{"ignore":["<root>/fixtures/**"],"cwd":"fixtures","absolute":true}} (stream) 1'] = []
+
+exports['Options Absolute (cwd & ignore) {"pattern":"file.md","options":{"ignore":["**/fixtures/**"],"cwd":"fixtures","absolute":true}} (sync) 1'] = [
+  "<root>/fixtures/file.md"
+]
+
+exports['Options Absolute (cwd & ignore) {"pattern":"file.md","options":{"ignore":["**/fixtures/**"],"cwd":"fixtures","absolute":true}} (async) 1'] = [
+  "<root>/fixtures/file.md"
+]
+
+exports['Options Absolute (cwd & ignore) {"pattern":"file.md","options":{"ignore":["**/fixtures/**"],"cwd":"fixtures","absolute":true}} (stream) 1'] = [
+  "<root>/fixtures/file.md"
+]

package.json

@@ -39,7 +39,7 @@
     "eslint-config-mrmlnc": "^1.1.0",
     "execa": "^7.1.1",
     "fast-glob": "^3.0.4",
-    "fdir": "^6.0.1",
+    "fdir": "6.0.1",
     "glob": "^10.0.0",
     "hereby": "^1.8.1",
     "mocha": "^6.2.1",
@@ -53,7 +53,7 @@
     "@nodelib/fs.walk": "^1.2.3",
     "glob-parent": "^5.1.2",
     "merge2": "^1.3.0",
-    "micromatch": "^4.0.4"
+    "micromatch": "^4.0.8"
   },
   "scripts": {
     "clean": "rimraf out",
@@ -65,7 +65,7 @@
     "test:e2e:async": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(async\\)\"",
     "test:e2e:stream": "mocha \"out/**/*.e2e.js\" -s 0 --grep \"\\(stream\\)\"",
     "build": "npm run clean && npm run compile && npm run lint && npm test",
-    "watch": "npm run clean && npm run compile -- --sourceMap --watch",
+    "watch": "npm run clean && npm run compile -- -- --sourceMap --watch",
     "bench:async": "npm run bench:product:async && npm run bench:regression:async",
     "bench:stream": "npm run bench:product:stream && npm run bench:regression:stream",
     "bench:sync": "npm run bench:product:sync && npm run bench:regression:sync",

src/providers/filters/entry.ts

@@ -2,22 +2,38 @@ import Settings from '../../settings';
 import { Entry, EntryFilterFunction, MicromatchOptions, Pattern, PatternRe } from '../../types';
 import * as utils from '../../utils';
 
+type PatternsRegexSet = {
+	positive: {
+		all: PatternRe[];
+	};
+	negative: {
+		absolute: PatternRe[];
+		relative: PatternRe[];
+	};
+};
+
 export default class EntryFilter {
 	public readonly index: Map<string, undefined> = new Map();
 
 	constructor(private readonly _settings: Settings, private readonly _micromatchOptions: MicromatchOptions) {}
 
 	public getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction {
-		const positiveRe = utils.pattern.convertPatternsToRe(positive, this._micromatchOptions);
-		const negativeRe = utils.pattern.convertPatternsToRe(negative, {
-			...this._micromatchOptions,
-			dot: true
-		});
-
-		return (entry) => this._filter(entry, positiveRe, negativeRe);
+		const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
+
+		const patterns: PatternsRegexSet = {
+			positive: {
+				all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
+			},
+			negative: {
+				absolute: utils.pattern.convertPatternsToRe(absoluteNegative, { ...this._micromatchOptions, dot: true }),
+				relative: utils.pattern.convertPatternsToRe(relativeNegative, { ...this._micromatchOptions, dot: true })
+			}
+		};
+
+		return (entry) => this._filter(entry, patterns);
 	}
 
-	private _filter(entry: Entry, positiveRe: PatternRe[], negativeRe: PatternRe[]): boolean {
+	private _filter(entry: Entry, patterns: PatternsRegexSet): boolean {
 		const filepath = utils.path.removeLeadingDotSegment(entry.path);
 
 		if (this._settings.unique && this._isDuplicateEntry(filepath)) {
@@ -28,13 +44,7 @@ export default class EntryFilter {
 			return false;
 		}
 
-		if (this._isSkippedByAbsoluteNegativePatterns(filepath, negativeRe)) {
-			return false;
-		}
-
-		const isDirectory = entry.dirent.isDirectory();
-
-		const isMatched = this._isMatchToPatterns(filepath, positiveRe, isDirectory) && !this._isMatchToPatterns(filepath, negativeRe, isDirectory);
+		const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
 
 		if (this._settings.unique && isMatched) {
 			this._createIndexRecord(filepath);
@@ -59,17 +69,40 @@ export default class EntryFilter {
 		return this._settings.onlyDirectories && !entry.dirent.isDirectory();
 	}
 
-	private _isSkippedByAbsoluteNegativePatterns(entryPath: string, patternsRe: PatternRe[]): boolean {
-		if (!this._settings.absolute) {
+	private _isMatchToPatternsSet(filepath: string, patterns: PatternsRegexSet, isDirectory: boolean): boolean {
+		const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
+		if (!isMatched) {
+			return false;
+		}
+
+		const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
+		if (isMatchedByRelativeNegative) {
+			return false;
+		}
+
+		const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
+		if (isMatchedByAbsoluteNegative) {
+			return false;
+		}
+
+		return true;
+	}
+
+	private _isMatchToAbsoluteNegative(filepath: string, patternsRe: PatternRe[], isDirectory: boolean): boolean {
+		if (patternsRe.length === 0) {
 			return false;
 		}
 
-		const fullpath = utils.path.makeAbsolute(this._settings.cwd, entryPath);
+		const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
 
-		return utils.pattern.matchAny(fullpath, patternsRe);
+		return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
 	}
 
 	private _isMatchToPatterns(filepath: string, patternsRe: PatternRe[], isDirectory: boolean): boolean {
+		if (patternsRe.length === 0) {
+			return false;
+		}
+
 		// Trying to match files and directories by patterns.
 		const isMatched = utils.pattern.matchAny(filepath, patternsRe);
 

src/tests/e2e/options/absolute.e2e.ts

@@ -121,6 +121,14 @@ runner.suite('Options Absolute (cwd & ignore)', {
 				absolute: true
 			}
 		},
+		{
+			pattern: 'file.md',
+			options: {
+				ignore: [path.posix.join('**', 'fixtures', '**')],
+				cwd: 'fixtures',
+				absolute: true
+			}
+		},
 
 		{
 			pattern: '*',

src/utils/pattern.spec.ts

@@ -539,4 +539,18 @@ describe('Utils → Pattern', () => {
 			assert.strictEqual(action('///?/D:/'), '//?/D:/');
 		});
 	});
+
+	describe('.isAbsolute', () => {
+		it('should return true', () => {
+			const actual = util.isAbsolute('/directory/file.txt');
+
+			assert.ok(actual);
+		});
+
+		it('should return false', () => {
+			const actual = util.isAbsolute('directory/file.txt');
+
+			assert.ok(!actual);
+		});
+	});
 });

src/utils/pattern.ts

@@ -215,3 +215,22 @@ export function matchAny(entry: string, patternsRe: PatternRe[]): boolean {
 export function removeDuplicateSlashes(pattern: string): string {
 	return pattern.replace(DOUBLE_SLASH_RE, '/');
 }
+
+export function partitionAbsoluteAndRelative(patterns: Pattern[]): Pattern[][] {
+	const absolute: Pattern[] = [];
+	const relative: Pattern[] = [];
+
+	for (const pattern of patterns) {
+		if (isAbsolute(pattern)) {
+			absolute.push(pattern);
+		} else {
+			relative.push(pattern);
+		}
+	}
+
+	return [absolute, relative];
+}
+
+export function isAbsolute(pattern: string): boolean {
+	return path.isAbsolute(pattern);
+}