Merge pull request #200 from mrmlnc/fix_some_issues

mrmlnc · web-flow · commit f3642dca0af4 · 2019-06-09T22:54:23.000+03:00
ISSUE-181: fix some issues
diff --git a/README.md b/README.md
@@ -138,10 +138,10 @@ The current working directory in which to search.
 
 #### deep
 
-  * Type: `number|boolean`
-  * Default: `true`
+  * Type: `number`
+  * Default: `Infinity`
 
-The deep option can be set to `true` to traverse the entire directory structure, or it can be set to a *number* to only traverse that many levels deep. The countdown begins with `1`.
+The deep option can be set to `Infinity` to traverse the entire directory structure, or it can be set to a *number* to only traverse that many levels deep. The countdown begins with `1`.
 
 For example, you have the following tree:
 
@@ -180,6 +180,13 @@ An array of glob patterns to exclude matches.
 
 Allow patterns to match filenames starting with a period (files & directories), even if the pattern does not explicitly have a period in that spot.
 
+#### objectMode
+
+  * Type: `boolean`
+  * Default: `false`
+
+Return an [`Entry`](#entry) object instead of filepath.
+
 #### stats
 
   * Type: `boolean`
@@ -291,38 +298,6 @@ Allow glob patterns without slashes to match a file path based on its basename.
 Suppress any errors from reader. Works only with Node.js 10.10+.
 Can be useful when the directory has entries with a special level of access.
 
-#### transform
-
-  * Type: `Function`
-  * Default: `null`
-
-Allows you to transform a path or `fs.Stats` object before sending to the array.
-
-```js
-const fg = require('fast-glob');
-
-const entries1 = fg.sync(['**/*.scss']);
-const entries2 = fg.sync(['**/*.scss'], { transform: (entry) => '_' + entry });
-
-console.log(entries1); // ['a.scss', 'b.scss']
-console.log(entries2); // ['_a.scss', '_b.scss']
-```
-
-If you are using **TypeScript**, you probably want to specify your own type of the returned array.
-
-```ts
-import * as fg from 'fast-glob';
-
-interface IMyOwnEntry {
-	path: string;
-}
-
-const entries: IMyOwnEntry[] = fg.sync<IMyOwnEntry>(['*.md'], {
-	transform: (entry) => typeof entry === 'string' ? { path: entry } : { path: entry.path }
-	// Will throw compilation error for non-IMyOwnEntry types (boolean, for example)
-});
-```
-
 #### fs
 
 * Type: `FileSystemAdapter`
diff --git a/src/index.ts b/src/index.ts
@@ -3,37 +3,50 @@ import ProviderAsync from './providers/async';
 import Provider from './providers/provider';
 import ProviderStream from './providers/stream';
 import ProviderSync from './providers/sync';
-import Settings, { Options, TransformFunction } from './settings';
-import { EntryItem, Pattern } from './types/index';
+import Settings, { Options } from './settings';
+import { Entry, EntryItem, Pattern } from './types/index';
 import * as utils from './utils/index';
 
 type Task = taskManager.Task;
 
+type EntryObjectModePredicate = { [P in keyof Pick<Options, 'objectMode'>]-?: true };
+type EntryStatsPredicate = { [P in keyof Pick<Options, 'stats'>]-?: true };
+type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+
+function sync(source: Pattern | Pattern[], options: Options & EntryObjectPredicate): Entry[];
+function sync(source: Pattern | Pattern[], options?: Options): string[];
 function sync(source: Pattern | Pattern[], options?: Options): EntryItem[] {
 	assertPatternsInput(source);
 
-	const works = getWorks<EntryItem[]>(source, ProviderSync, options);
+	const works = getWorks(source, ProviderSync, options);
 
 	return utils.array.flatten(works);
 }
 
+function async(source: Pattern | Pattern[], options: Options & EntryObjectPredicate): Promise<Entry[]>;
+function async(source: Pattern | Pattern[], options?: Options): Promise<string[]>;
 function async(source: Pattern | Pattern[], options?: Options): Promise<EntryItem[]> {
 	try {
 		assertPatternsInput(source);
 	} catch (error) {
 		return Promise.reject(error);
 	}
 
-	const works = getWorks<Promise<EntryItem[]>>(source, ProviderAsync, options);
+	const works = getWorks(source, ProviderAsync, options);
 
 	return Promise.all(works).then(utils.array.flatten);
 }
 
 function stream(source: Pattern | Pattern[], options?: Options): NodeJS.ReadableStream {
 	assertPatternsInput(source);
 
-	const works = getWorks<NodeJS.ReadableStream>(source, ProviderStream, options);
+	const works = getWorks(source, ProviderStream, options);
 
+	/**
+	 * The stream returned by the provider cannot work with an asynchronous iterator.
+	 * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
+	 * This affects performance (+25%). I don't see best solution right now.
+	 */
 	return utils.stream.merge(works);
 }
 
@@ -78,7 +91,6 @@ export {
 
 	Options,
 	Settings,
-	TransformFunction,
 	Task,
 	EntryItem
 };
diff --git a/src/providers/async.spec.ts b/src/providers/async.spec.ts
@@ -74,17 +74,6 @@ describe('Providers → ProviderAsync', () => {
 			assert.deepStrictEqual(actual, expected);
 		});
 
-		it('should call the transform function when it is presented', async () => {
-			const transform = sinon.stub();
-			const provider = getProvider({ transform });
-			const task = tests.task.builder().base('.').positive('*').build();
-			const entry = tests.entry.builder().path('root/file.txt').file().build();
-
-			await getEntries(provider, task, entry);
-
-			assert.strictEqual(transform.callCount, 1);
-		});
-
 		it('should throw error', async () => {
 			const provider = getProvider();
 			const task = tests.task.builder().base('.').positive('*').build();
diff --git a/src/providers/filters/deep.spec.ts b/src/providers/filters/deep.spec.ts
@@ -28,8 +28,8 @@ describe('Providers → Filters → Deep', () => {
 
 	describe('.getFilter', () => {
 		describe('options.deep', () => {
-			it('should return `false` when option is disabled', () => {
-				const filter = getFilter('.', ['**/*'], [], { deep: false });
+			it('should return `false` when option has 0 as value', () => {
+				const filter = getFilter('.', ['**/*'], [], { deep: 0 });
 				const entry = tests.entry.builder().path('root/directory').directory().build();
 
 				const actual = filter(entry);
diff --git a/src/providers/filters/deep.ts b/src/providers/filters/deep.ts
@@ -56,7 +56,7 @@ export default class DeepFilter {
 	}
 
 	private _isSkippedByDeep(entryDepth: number): boolean {
-		return !this._settings.deep || (typeof this._settings.deep === 'number' && entryDepth >= this._settings.deep);
+		return entryDepth >= this._settings.deep;
 	}
 
 	private _isSkippedByMaxPatternDepth(entryDepth: number, maxPatternDepth: number): boolean {
diff --git a/src/providers/provider.spec.ts b/src/providers/provider.spec.ts
@@ -103,7 +103,8 @@ describe('Providers → Provider', () => {
 				nobrace: false,
 				nocase: false,
 				noext: false,
-				noglobstar: false
+				noglobstar: false,
+				posix: true
 			};
 
 			const actual = provider.getMicromatchOptions();
diff --git a/src/providers/provider.ts b/src/providers/provider.ts
@@ -42,11 +42,12 @@ export default abstract class Provider<T> {
 	protected _getMicromatchOptions(): MicromatchOptions {
 		return {
 			dot: this._settings.dot,
+			matchBase: this._settings.matchBase,
 			nobrace: !this._settings.braceExpansion,
-			noglobstar: !this._settings.globstar,
-			noext: !this._settings.extglob,
 			nocase: !this._settings.caseSensitiveMatch,
-			matchBase: this._settings.matchBase
+			noext: !this._settings.extglob,
+			noglobstar: !this._settings.globstar,
+			posix: true
 		};
 	}
 }
diff --git a/src/providers/stream.spec.ts b/src/providers/stream.spec.ts
@@ -82,17 +82,6 @@ describe('Providers → ProviderStream', () => {
 			assert.deepStrictEqual(actual, expected);
 		});
 
-		it('should call the transform function when it is presented', async () => {
-			const transform = sinon.stub();
-			const provider = getProvider({ transform });
-			const task = tests.task.builder().base('.').positive('*').build();
-			const entry = tests.entry.builder().path('root/file.txt').file().build();
-
-			await getEntries(provider, task, entry);
-
-			assert.strictEqual(transform.callCount, 1);
-		});
-
 		it('should emit error to the transform stream', (done) => {
 			const provider = getProvider();
 			const task = tests.task.builder().base('.').positive('*').build();
diff --git a/src/providers/sync.spec.ts b/src/providers/sync.spec.ts
@@ -62,18 +62,5 @@ describe('Providers → ProviderSync', () => {
 			assert.strictEqual(provider.reader.static.callCount, 1);
 			assert.deepStrictEqual(actual, expected);
 		});
-
-		it('should call the transform function when it is presented', () => {
-			const transform = sinon.stub();
-			const provider = getProvider({ transform });
-			const task = tests.task.builder().base('.').positive('*').build();
-			const entry = tests.entry.builder().path('root/file.txt').file().build();
-
-			provider.reader.dynamic.returns([entry]);
-
-			provider.read(task);
-
-			assert.strictEqual(transform.callCount, 1);
-		});
 	});
 });
diff --git a/src/providers/sync.ts b/src/providers/sync.ts
@@ -12,7 +12,7 @@ export default class ProviderSync extends Provider<EntryItem[]> {
 
 		const entries = this.api(root, task, options);
 
-		return entries.map<EntryItem>(options.transform);
+		return entries.map(options.transform);
 	}
 
 	public api(root: string, task: Task, options: ReaderOptions): Entry[] {
diff --git a/src/providers/transformers/entry.spec.ts b/src/providers/transformers/entry.spec.ts
@@ -36,26 +36,26 @@ describe('Providers → Transformers → Entry', () => {
 			assert.strictEqual(actual, expected);
 		});
 
-		it('should return transformed entry as object when the `stats` option is enabled', () => {
-			const transformer = getTransformer({ stats: true });
+		it('should return transformed entry as object when the `objectMode` option is enabled', () => {
+			const transformer = getTransformer({ objectMode: true });
 			const entry = tests.entry.builder().path('root/file.txt').file().build();
 
 			const expected = entry;
 
 			const actual = transformer(entry);
 
-			assert.deepEqual(actual, expected);
+			assert.deepStrictEqual(actual, expected);
 		});
 
-		it('should apply custom transform function', () => {
-			const transformer = getTransformer({ transform: () => 'cake' });
-			const entry = tests.entry.builder().path('root/file.txt').file().build();
+		it('should return transformed entry as object when the `stats` option is enabled', () => {
+			const transformer = getTransformer({ stats: true });
+			const entry = tests.entry.builder().path('root/file.txt').file().stats().build();
 
-			const expected = 'cake';
+			const expected = entry;
 
 			const actual = transformer(entry);
 
-			assert.strictEqual(actual, expected);
+			assert.deepStrictEqual(actual, expected);
 		});
 
 		it('should return entry with absolute filepath when the `absolute` option is enabled', () => {
diff --git a/src/providers/transformers/entry.ts b/src/providers/transformers/entry.ts
@@ -22,12 +22,10 @@ export default class EntryTransformer {
 
 		entry.path = utils.path.unixify(entry.path);
 
-		const item = this._settings.stats ? entry : entry.path;
-
-		if (this._settings.transform === null) {
-			return item;
+		if (this._settings.objectMode) {
+			return entry;
 		}
 
-		return this._settings.transform(item);
+		return entry.path;
 	}
 }
diff --git a/src/readers/reader.ts b/src/readers/reader.ts
@@ -17,7 +17,7 @@ export default abstract class Reader<T> {
 	constructor(protected readonly _settings: Settings) { }
 
 	public abstract dynamic(root: string, options: ReaderOptions): T;
-	public abstract static(filepath: string[], options: ReaderOptions): T;
+	public abstract static(patterns: Pattern[], options: ReaderOptions): T;
 
 	protected _getFullEntryPath(filepath: string): string {
 		return path.resolve(this._settings.cwd, filepath);
diff --git a/src/readers/stream.ts b/src/readers/stream.ts
@@ -23,7 +23,7 @@ export default class ReaderStream extends Reader<NodeJS.ReadableStream> {
 		return walk;
 	}
 
-	public static(patterns: string[], options: ReaderOptions): NodeJS.ReadableStream {
+	public static(patterns: Pattern[], options: ReaderOptions): NodeJS.ReadableStream {
 		const filepaths = patterns.map(this._getFullEntryPath, this);
 
 		const stream = new PassThrough({ objectMode: true });
diff --git a/src/settings.spec.ts b/src/settings.spec.ts
@@ -11,6 +11,7 @@ describe('Settings', () => {
 		assert.ok(settings.deep);
 		assert.deepStrictEqual(settings.ignore, []);
 		assert.ok(!settings.dot);
+		assert.ok(!settings.objectMode);
 		assert.ok(!settings.stats);
 		assert.ok(settings.onlyFiles);
 		assert.ok(!settings.onlyDirectories);
@@ -24,7 +25,6 @@ describe('Settings', () => {
 		assert.ok(settings.extglob);
 		assert.ok(settings.caseSensitiveMatch);
 		assert.ok(!settings.matchBase);
-		assert.strictEqual(settings.transform, null);
 		assert.ok(!settings.suppressErrors);
 		assert.deepStrictEqual(settings.fs, DEFAULT_FILE_SYSTEM_ADAPTER);
 	});
@@ -46,13 +46,13 @@ describe('Settings', () => {
 		assert.ok(settings.onlyDirectories);
 	});
 
-	it('should set the "throwErrorOnBrokenSymbolicLink" option to "true" when the "stats" option is enabled', () => {
+	it('should set the "objectMode" option when the "stats" is enabled', () => {
 		const settings = new Settings({
 			stats: true
 		});
 
+		assert.ok(settings.objectMode);
 		assert.ok(settings.stats);
-		assert.ok(settings.throwErrorOnBrokenSymbolicLink);
 	});
 
 	it('should return the `fs` option with custom method', () => {
diff --git a/src/settings.ts b/src/settings.ts
diff --git a/src/tests/smoke/smoke.ts b/src/tests/smoke/smoke.ts
diff --git a/src/tests/smoke/static.smoke.ts b/src/tests/smoke/static.smoke.ts
diff --git a/src/types/index.ts b/src/types/index.ts
diff --git a/src/utils/stream.spec.ts b/src/utils/stream.spec.ts
diff --git a/src/utils/stream.ts b/src/utils/stream.ts

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ export default class DeepFilter {`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`private _isSkippedByDeep(entryDepth: number): boolean {`
`59`		`- return !this._settings.deep \|\| (typeof this._settings.deep === 'number' && entryDepth >= this._settings.deep);`
	`59`	`+ return entryDepth >= this._settings.deep;`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`private _isSkippedByMaxPatternDepth(entryDepth: number, maxPatternDepth: number): boolean {`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ export default class ProviderSync extends Provider<EntryItem[]> {`
`12`	`12`
`13`	`13`	`const entries = this.api(root, task, options);`
`14`	`14`
`15`		`- return entries.map<EntryItem>(options.transform);`
	`15`	`+ return entries.map(options.transform);`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public api(root: string, task: Task, options: ReaderOptions): Entry[] {`