Minor code style tweaks

source/as-promise.js

@@ -17,29 +17,29 @@ module.exports = options => {
 			cancelOnRequest = true;
 		});
 
-		emitter.on('request', req => {
+		emitter.on('request', request => {
 			if (cancelOnRequest) {
-				req.abort();
+				request.abort();
 			}
 
-			proxy.emit('request', req);
+			proxy.emit('request', request);
 
 			const uploadComplete = () => {
-				req.emit('upload-complete');
+				request.emit('upload-complete');
 			};
 
 			onCancel(() => {
-				req.abort();
+				request.abort();
 			});
 
 			if (is.nodeStream(options.body)) {
 				options.body.once('end', uploadComplete);
-				options.body.pipe(req);
+				options.body.pipe(request);
 				options.body = undefined;
 				return;
 			}
 
-			req.end(options.body, uploadComplete);
+			request.end(options.body, uploadComplete);
 		});
 
 		emitter.on('response', async response => {

source/as-stream.js

@@ -26,30 +26,30 @@ module.exports = options => {
 
 	const emitter = requestAsEventEmitter(options);
 
-	emitter.on('request', req => {
-		proxy.emit('request', req);
+	emitter.on('request', request => {
+		proxy.emit('request', request);
 		const uploadComplete = () => {
-			req.emit('upload-complete');
+			request.emit('upload-complete');
 		};
 
 		if (is.nodeStream(options.body)) {
 			options.body.once('end', uploadComplete);
-			options.body.pipe(req);
+			options.body.pipe(request);
 			return;
 		}
 
 		if (options.body) {
-			req.end(options.body, uploadComplete);
+			request.end(options.body, uploadComplete);
 			return;
 		}
 
 		if (options.method === 'POST' || options.method === 'PUT' || options.method === 'PATCH') {
 			input.once('end', uploadComplete);
-			input.pipe(req);
+			input.pipe(request);
 			return;
 		}
 
-		req.end(uploadComplete);
+		request.end(uploadComplete);
 	});
 
 	emitter.on('response', response => {

source/assign-options.js

@@ -2,26 +2,26 @@ const extend = require('extend');
 const is = require('@sindresorhus/is');
 
 module.exports = (defaults, options = {}) => {
-	const opts = extend(true, {}, defaults, options);
+	const returnOptions = extend(true, {}, defaults, options);
 
 	if (Reflect.has(options, 'headers')) {
 		for (const [key, value] of Object.entries(options.headers)) {
 			if (is.nullOrUndefined(value)) {
-				delete opts.headers[key];
+				delete returnOptions.headers[key];
 			}
 		}
 	}
 
 	// Override these arrays because we don't want to extend them
 	if (is.object(options.retry)) {
 		if (Reflect.has(options.retry, 'methods')) {
-			opts.retry.methods = options.retry.methods;
+			returnOptions.retry.methods = options.retry.methods;
 		}
 
 		if (Reflect.has(options.retry, 'statusCodes')) {
-			opts.retry.statusCodes = options.retry.statusCodes;
+			returnOptions.retry.statusCodes = options.retry.statusCodes;
 		}
 	}
 
-	return opts;
+	return returnOptions;
 };

source/create.js

@@ -6,13 +6,7 @@ const asPromise = require('./as-promise');
 const normalizeArguments = require('./normalize-arguments');
 const deepFreeze = require('./deep-freeze');
 
-const next = options => {
-	if (options.stream) {
-		return asStream(options);
-	}
-
-	return asPromise(options);
-};
+const next = options => options.stream ? asStream(options) : asPromise(options);
 
 const create = defaults => {
 	if (!defaults.handler) {

source/deep-freeze.js

@@ -1,12 +1,12 @@
 'use strict';
 const is = require('@sindresorhus/is');
 
-module.exports = function deepFreeze(obj) {
-	for (const [key, value] of Object.entries(obj)) {
+module.exports = function deepFreeze(object) {
+	for (const [key, value] of Object.entries(object)) {
 		if (is.object(value)) {
-			deepFreeze(obj[key]);
+			deepFreeze(object[key]);
 		}
 	}
 
-	return Object.freeze(obj);
+	return Object.freeze(object);
 };

source/get-response.js

@@ -14,7 +14,7 @@ module.exports = (response, options, emitter, redirects) => {
 
 			const percent = downloadBodySize ? downloaded / downloadBodySize : 0;
 
-			// Let flush() be responsible for emitting the last event
+			// Let `flush()` be responsible for emitting the last event
 			if (percent < 1) {
 				emitter.emit('downloadProgress', {
 					percent,

source/index.js

@@ -14,8 +14,22 @@ const defaults = {
 	options: {
 		retry: {
 			retries: 2,
-			methods: ['GET', 'PUT', 'HEAD', 'DELETE', 'OPTIONS', 'TRACE'],
-			statusCodes: [408, 413, 429, 502, 503, 504]
+			methods: [
+				'GET',
+				'PUT',
+				'HEAD',
+				'DELETE',
+				'OPTIONS',
+				'TRACE'
+			],
+			statusCodes: [
+				408,
+				413,
+				429,
+				502,
+				503,
+				504
+			]
 		},
 		cache: false,
 		decompress: true,

source/is-retry-on-network-error-allowed.js

@@ -9,8 +9,8 @@ const WHITELIST = new Set([
 	'EPIPE'
 ]);
 
-module.exports = err => {
-	if (err && WHITELIST.has(err.code)) {
+module.exports = error => {
+	if (error && WHITELIST.has(error.code)) {
 		return true;
 	}
 

source/normalize-arguments.js

@@ -204,15 +204,13 @@ module.exports = (url, options, defaults) => {
 			if (is.nullOrUndefined(hooks)) {
 				options.hooks[hookEvent] = [];
 			} else if (is.array(hooks)) {
-				hooks.forEach(
-					(hook, index) => {
-						if (!is.function_(hook)) {
-							throw new TypeError(
-								`Parameter \`hooks.${hookEvent}[${index}]\` must be a function, not ${is(hook)}`
-							);
-						}
+				for (const [index, hook] of hooks.entries()) {
+					if (!is.function(hook)) {
+						throw new TypeError(
+							`Parameter \`hooks.${hookEvent}[${index}]\` must be a function, not ${is(hook)}`
+						);
 					}
-				);
+				}
 			} else {
 				throw new TypeError(`Parameter \`hooks.${hookEvent}\` must be an array, not ${is(hooks)}`);
 			}

source/progress.js

@@ -1,6 +1,6 @@
 'use strict';
 module.exports = {
-	upload(req, emitter, uploadBodySize) {
+	upload(request, emitter, uploadBodySize) {
 		const uploadEventFrequency = 150;
 		let uploaded = 0;
 		let progressInterval;
@@ -11,11 +11,11 @@ module.exports = {
 			total: uploadBodySize
 		});
 
-		req.once('error', () => {
+		request.once('error', () => {
 			clearInterval(progressInterval);
 		});
 
-		req.once('response', () => {
+		request.once('response', () => {
 			clearInterval(progressInterval);
 
 			emitter.emit('uploadProgress', {
@@ -25,7 +25,7 @@ module.exports = {
 			});
 		});
 
-		req.once('socket', socket => {
+		request.once('socket', socket => {
 			const onSocketConnect = () => {
 				progressInterval = setInterval(() => {
 					if (socket.destroyed) {
@@ -34,7 +34,7 @@ module.exports = {
 					}
 
 					const lastUploaded = uploaded;
-					const headersSize = req._header ? Buffer.byteLength(req._header) : 0;
+					const headersSize = request._header ? Buffer.byteLength(request._header) : 0;
 					uploaded = socket.bytesWritten - headersSize;
 
 					// Prevent the known issue of `bytesWritten` being larger than body size

source/request-as-event-emitter.js

@@ -106,13 +106,13 @@ module.exports = (options = {}) => {
 			}
 		});
 
-		cacheReq.once('request', req => {
+		cacheReq.once('request', request => {
 			let aborted = false;
-			req.once('abort', _ => {
+			request.once('abort', _ => {
 				aborted = true;
 			});
 
-			req.once('error', error => {
+			request.once('error', error => {
 				if (aborted) {
 					return;
 				}
@@ -127,13 +127,13 @@ module.exports = (options = {}) => {
 				});
 			});
 
-			progress.upload(req, emitter, uploadBodySize);
+			progress.upload(request, emitter, uploadBodySize);
 
 			if (options.gotTimeout) {
-				timedOut(req, options);
+				timedOut(request, options);
 			}
 
-			emitter.emit('request', req);
+			emitter.emit('request', request);
 		});
 	};
 

source/timed-out.js

@@ -26,23 +26,25 @@ function addTimeout(delay, callback, ...args) {
 	};
 }
 
-module.exports = function (req, options) {
-	if (req[reentry]) {
+module.exports = (request, options) => {
+	if (request[reentry]) {
 		return;
 	}
-	req[reentry] = true;
+
+	request[reentry] = true;
 	const {gotTimeout: delays, host, hostname} = options;
 	const timeoutHandler = (delay, event) => {
-		req.abort();
-		req.emit('error', new TimeoutError(delay, event, options));
+		request.abort();
+		request.emit('error', new TimeoutError(delay, event, options));
 	};
+
 	const cancelers = [];
 	const cancelTimeouts = () => {
 		cancelers.forEach(cancelTimeout => cancelTimeout());
 	};
 
-	req.on('error', cancelTimeouts);
-	req.once('response', response => {
+	request.on('error', cancelTimeouts);
+	request.once('response', response => {
 		response.once('end', cancelTimeouts);
 	});
 
@@ -54,16 +56,18 @@ module.exports = function (req, options) {
 		);
 		cancelers.push(cancelTimeout);
 	}
+
 	if (delays.socket !== undefined) {
-		req.setTimeout(
+		request.setTimeout(
 			delays.socket,
 			() => {
 				timeoutHandler(delays.socket, 'socket');
 			}
 		);
 	}
-	if (delays.lookup !== undefined && !req.socketPath && !net.isIP(hostname || host)) {
-		req.once('socket', socket => {
+
+	if (delays.lookup !== undefined && !request.socketPath && !net.isIP(hostname || host)) {
+		request.once('socket', socket => {
 			if (socket.connecting) {
 				const cancelTimeout = addTimeout(
 					delays.lookup,
@@ -75,8 +79,9 @@ module.exports = function (req, options) {
 			}
 		});
 	}
+
 	if (delays.connect !== undefined) {
-		req.once('socket', socket => {
+		request.once('socket', socket => {
 			if (socket.connecting) {
 				const timeConnect = () => {
 					const cancelTimeout = addTimeout(
@@ -87,7 +92,8 @@ module.exports = function (req, options) {
 					cancelers.push(cancelTimeout);
 					return cancelTimeout;
 				};
-				if (req.socketPath || net.isIP(hostname || host)) {
+
+				if (request.socketPath || net.isIP(hostname || host)) {
 					socket.once('connect', timeConnect());
 				} else {
 					socket.once('lookup', () => {
@@ -97,8 +103,9 @@ module.exports = function (req, options) {
 			}
 		});
 	}
+
 	if (delays.send !== undefined) {
-		req.once('socket', socket => {
+		request.once('socket', socket => {
 			const timeRequest = () => {
 				const cancelTimeout = addTimeout(
 					delays.send,
@@ -108,24 +115,26 @@ module.exports = function (req, options) {
 				cancelers.push(cancelTimeout);
 				return cancelTimeout;
 			};
+
 			if (socket.connecting) {
 				socket.once('connect', () => {
-					req.once('upload-complete', timeRequest());
+					request.once('upload-complete', timeRequest());
 				});
 			} else {
-				req.once('upload-complete', timeRequest());
+				request.once('upload-complete', timeRequest());
 			}
 		});
 	}
+
 	if (delays.response !== undefined) {
-		req.once('upload-complete', () => {
+		request.once('upload-complete', () => {
 			const cancelTimeout = addTimeout(
 				delays.response,
 				timeoutHandler,
 				'response'
 			);
 			cancelers.push(cancelTimeout);
-			req.once('response', cancelTimeout);
+			request.once('response', cancelTimeout);
 		});
 	}
 };