Ensuring node modules are up to date for running

node_modules/@nodelib/fs.walk/src/providers/async.spec.ts

@@ -0,0 +1,57 @@
+import * as assert from 'assert';
+
+import * as sinon from 'sinon';
+
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+import * as tests from '../tests';
+import AsyncProvider from './async';
+
+class TestProvider extends AsyncProvider {
+	protected readonly _reader: AsyncReader = new tests.TestAsyncReader() as unknown as AsyncReader;
+
+	constructor(_root: string, _settings: Settings = new Settings()) {
+		super(_root, _settings);
+	}
+
+	public get reader(): tests.TestAsyncReader {
+		return this._reader as unknown as tests.TestAsyncReader;
+	}
+}
+
+describe('Providers → Async', () => {
+	describe('.read', () => {
+		it('should call reader function with correct set of arguments', () => {
+			const provider = new TestProvider('directory');
+			const fakeCallback = sinon.stub();
+
+			provider.read(fakeCallback);
+
+			assert.ok(provider.reader.read.called);
+		});
+
+		it('should call callback with error for failed launch', () => {
+			const provider = new TestProvider('directory');
+			const fakeCallback = sinon.stub();
+
+			provider.reader.onError.yields(tests.EPERM_ERRNO);
+
+			provider.read(fakeCallback);
+
+			assert.deepStrictEqual(fakeCallback.args, [[tests.EPERM_ERRNO]]);
+		});
+
+		it('should push entries to storage and call callback with array of entries', () => {
+			const provider = new TestProvider('directory');
+			const fakeEntry = tests.buildFakeFileEntry();
+			const fakeCallback = sinon.stub();
+
+			provider.reader.onEntry.yields(fakeEntry);
+			provider.reader.onEnd.yields();
+
+			provider.read(fakeCallback);
+
+			assert.deepStrictEqual(fakeCallback.args, [[null, [fakeEntry]]]);
+		});
+	});
+});

node_modules/@nodelib/fs.walk/src/providers/async.ts

@@ -0,0 +1,40 @@
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+import { Entry, Errno } from '../types';
+
+type FailureCallback = (err: Errno) => void;
+type SuccessCallback = (err: null, entries: Entry[]) => void;
+
+export type AsyncCallback = (err: Errno, entries: Entry[]) => void;
+
+export default class AsyncProvider {
+	protected readonly _reader: AsyncReader = new AsyncReader(this._root, this._settings);
+
+	private readonly _storage: Set<Entry> = new Set();
+
+	constructor(private readonly _root: string, private readonly _settings: Settings) { }
+
+	public read(callback: AsyncCallback): void {
+		this._reader.onError((error) => {
+			callFailureCallback(callback, error);
+		});
+
+		this._reader.onEntry((entry: Entry) => {
+			this._storage.add(entry);
+		});
+
+		this._reader.onEnd(() => {
+			callSuccessCallback(callback, [...this._storage]);
+		});
+
+		this._reader.read();
+	}
+}
+
+function callFailureCallback(callback: AsyncCallback, error: Errno): void {
+	(callback as FailureCallback)(error);
+}
+
+function callSuccessCallback(callback: AsyncCallback, entries: Entry[]): void {
+	(callback as unknown as SuccessCallback)(null, entries);
+}

node_modules/@nodelib/fs.walk/src/providers/index.ts

@@ -0,0 +1,9 @@
+import AsyncProvider from './async';
+import StreamProvider from './stream';
+import SyncProvider from './sync';
+
+export {
+	AsyncProvider,
+	StreamProvider,
+	SyncProvider
+};

node_modules/@nodelib/fs.walk/src/providers/stream.spec.ts

@@ -0,0 +1,90 @@
+import * as assert from 'assert';
+import { Readable } from 'stream';
+
+import * as sinon from 'sinon';
+
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+import * as tests from '../tests';
+import StreamProvider from './stream';
+
+class TestProvider extends StreamProvider {
+	protected readonly _reader: AsyncReader = new tests.TestAsyncReader() as unknown as AsyncReader;
+
+	constructor(_root: string, _settings: Settings = new Settings()) {
+		super(_root, _settings);
+
+		this._stream.emit = sinon.stub();
+		this._stream.push = sinon.stub();
+	}
+
+	public get reader(): tests.TestAsyncReader {
+		return this._reader as unknown as tests.TestAsyncReader;
+	}
+
+	public get stream(): sinon.SinonStubbedInstance<Readable> {
+		return this._stream as unknown as sinon.SinonStubbedInstance<Readable>;
+	}
+}
+
+describe('Providers → Stream', () => {
+	describe('.read', () => {
+		it('should return stream', () => {
+			const provider = new TestProvider('directory');
+
+			const stream = provider.read();
+
+			assert.ok(stream instanceof Readable);
+		});
+
+		it('should call reader function with correct set of arguments', () => {
+			const provider = new TestProvider('directory');
+
+			provider.read();
+
+			assert.ok(provider.reader.read.called);
+		});
+
+		it('should re-emit the "error" event from reader', () => {
+			const provider = new TestProvider('directory');
+
+			provider.reader.onError.yields(tests.EPERM_ERRNO);
+
+			provider.read();
+
+			assert.deepStrictEqual(provider.stream.emit.args, [['error', tests.EPERM_ERRNO]]);
+		});
+
+		it('should call the "push" method with entry value for the "entry" event from reader', () => {
+			const provider = new TestProvider('directory');
+			const fakeEntry = tests.buildFakeFileEntry();
+
+			provider.reader.onEntry.yields(fakeEntry);
+
+			provider.read();
+
+			assert.deepStrictEqual(provider.stream.push.args, [[fakeEntry]]);
+		});
+
+		it('should call the "push" method with "null" value for the "end" event from reader', () => {
+			const provider = new TestProvider('directory');
+
+			provider.reader.onEnd.yields();
+
+			provider.read();
+
+			assert.deepStrictEqual(provider.stream.push.args, [[null]]);
+		});
+
+		it('should do not destroy reader when it is already destroyed', () => {
+			const provider = new TestProvider('directory');
+
+			const stream = provider.read();
+
+			stream.destroy();
+
+			assert.ok(stream.destroyed);
+			assert.doesNotThrow(() => stream.destroy());
+		});
+	});
+});

node_modules/@nodelib/fs.walk/src/providers/stream.ts

@@ -0,0 +1,36 @@
+import { Readable } from 'stream';
+import AsyncReader from '../readers/async';
+import Settings from '../settings';
+
+export default class StreamProvider {
+	protected readonly _reader: AsyncReader = new AsyncReader(this._root, this._settings);
+	protected readonly _stream: Readable = new Readable({
+		objectMode: true,
+		read: () => { /* noop */ },
+		destroy: () => {
+			if (!this._reader.isDestroyed) {
+				this._reader.destroy();
+			}
+		}
+	});
+
+	constructor(private readonly _root: string, private readonly _settings: Settings) { }
+
+	public read(): Readable {
+		this._reader.onError((error) => {
+			this._stream.emit('error', error);
+		});
+
+		this._reader.onEntry((entry) => {
+			this._stream.push(entry);
+		});
+
+		this._reader.onEnd(() => {
+			this._stream.push(null);
+		});
+
+		this._reader.read();
+
+		return this._stream;
+	}
+}

node_modules/@nodelib/fs.walk/src/providers/sync.spec.ts

@@ -0,0 +1,34 @@
+import * as assert from 'assert';
+
+import SyncReader from '../readers/sync';
+import Settings from '../settings';
+import * as tests from '../tests';
+import SyncProvider from './sync';
+
+class TestProvider extends SyncProvider {
+	protected readonly _reader: SyncReader = new tests.TestSyncReader() as unknown as SyncReader;
+
+	constructor(_root: string, _settings: Settings = new Settings()) {
+		super(_root, _settings);
+	}
+
+	public get reader(): tests.TestSyncReader {
+		return this._reader as unknown as tests.TestSyncReader;
+	}
+}
+
+describe('Providers → Sync', () => {
+	describe('.read', () => {
+		it('should call reader function with correct set of arguments and got result', () => {
+			const provider = new TestProvider('directory');
+			const fakeEntry = tests.buildFakeFileEntry();
+
+			provider.reader.read.returns([fakeEntry]);
+
+			const actual = provider.read();
+
+			assert.deepStrictEqual(actual, [fakeEntry]);
+			assert.ok(provider.reader.read.called);
+		});
+	});
+});

node_modules/@nodelib/fs.walk/src/providers/sync.ts

@@ -0,0 +1,13 @@
+import SyncReader from '../readers/sync';
+import Settings from '../settings';
+import { Entry } from '../types';
+
+export default class SyncProvider {
+	protected readonly _reader: SyncReader = new SyncReader(this._root, this._settings);
+
+	constructor(private readonly _root: string, private readonly _settings: Settings) { }
+
+	public read(): Entry[] {
+		return this._reader.read();
+	}
+}