blogs_modules - npm Package Compare versions

Comparing version 0.0.2 to 0.0.3

lib/-cache.js

@@ -1,5 +0,4 @@
-var DONE = 1;
-var async = require('async');
-var isUndef = require('./is-undef');
 var forEachKey = require('./for-each-key');
+var isArray = require('./is-array');
+var isString = require('./is-string');
 
@@ -17,8 +16,11 @@ /**
  *   onRequest(req, res) {
- *     this.cache.get(req.url, (callback) => {
- *       this.readFile(req.url);
- *     }, (error, data) => {
- *       if (!error) {
- *         res.write(data);
- *       }
+ *     this.cache.get(req.url, q((callback) => {
+ *       fs.readFile(req.url, callback);
+ *     })).then((buffer) => {
+ *       res.statusCode = 200;
+ *       res.write(data);
+ *     }), (error) => {
+ *       res.statusCode = 404;
+ *     }).then(() => {
+ *       res.end();
  *     });
@@ -31,4 +33,3 @@ *   }
 	constructor(cacheCheckInterval) {
-		this.data = {};
-		this.queues = {};
+		this.promises = {};
 		this.start(cacheCheckInterval);
@@ -42,3 +43,3 @@ }
 	keys() {
-		return Object.keys(this.queues);
+		return Object.keys(this.promises);
 	}
@@ -52,3 +53,3 @@
 		var now = new Date().getTime();
-		forEachKey(this.data, (item, key) => {
+		forEachKey(this.promises, (item, key) => {
 			if (now < item.expiresAt) {
@@ -83,37 +84,35 @@ return;
 	 * Returns the cached data if it exists.
-	 * If the requested value is undefined, it calls the getter.
-	 * The argument of the getter is getterCallback which takes 3 parameters.
-	 *  1. error
-	 *  2. value - The requested value.
-	 *  3. [ttl=60] - Optional: Time to live [s]. Defaults to 60s.
+	 * If the requested value is undefined, it calls the getter which returns a promise object.
 	 * The expirations are reflected by cleanup().
-	 * Even if the ttl of a value is over, the value is valid until next cleanup().
+	 * Even if the ttl is over, the value is valid until next cleanup().
 	 * @param  {String} key
 	 * @param  {Function} getter - It is called with [getterCallback].
-	 * @param  {Function} callback - It is called with [error, value]
-	 * @return {undefined}
+	 * @param  {Number} ttl - Optional: Time to live [s]. Defaults to 60s.
+	 * @return {Promise}
 	 */
-	get(key, getter, callback) {
-		var data = this.data;
-		var queue = this.queues[key];
-		if (queue === DONE) {
-			callback(null, data[key].value);
-		} else if (isUndef(queue)) {
-			this.queues[key] = [callback];
-			getter((error, value, ttl = 60) => {
-				queue = this.queues[key];
-				if (!error) {
-					this.queues[key] = DONE;
-					data[key] = {
-						value: value,
-						expiresAt: new Date().getTime() + 1000 * ttl
+	get(key, getter, ttl = 60) {
+		var promise = this.promises[key];
+		if (!promise) {
+			promise = this.promises[key] = new Promise((resolve, reject) => {
+				setTimeout(() => {
+					var innerPromise;
+					var onError = (error) => {
+						this.clear(key);
+						reject(error);
 					};
-				}
-				while (0 < queue.length) {
-					queue.pop().call(null, error, value);
-				}
+					try {
+						innerPromise = getter();
+					} catch (error) {
+						onError(error);
+					}
+					if (innerPromise instanceof Promise) {
+						innerPromise.then(resolve, onError);
+					} else {
+						resolve(innerPromise);
+					}
+				});
 			});
-		} else {
-			queue.push(callback);
+			promise.expiresAt = new Date().getTime() + 1000 * ttl;
 		}
+		return promise;
 	}
@@ -124,31 +123,19 @@
 	 * If the key is falsy, all data will be deleted.
-	 * @param  {String} [key] - Optional: A key to be deleted.
-	 * @param  {Function} [callback] - Optional
-	 * @return {undefined}
+	 * @param  {String|Array} [keys] - Optional: A key or an array of keys to be deleted.
 	 */
-	clear(key, callback) {
-		var data = this.data;
-		var queues = this.queues;
-		var clear = (key, callback) => {
-			var queue = queues[key];
-			if (queue && queue !== DONE) {
-				queue.push(() => {
-					clear(key, callback);
-				});
-			} else {
-				delete data[key];
-				delete queues[key];
-				if (callback) {
-					callback();
-				}
-			}
-		};
-		if (!key) {
-			if (!callback) {
-				callback = () => {};
-			}
-			async.each(this.keys(), clear, callback);
+	clear(keys) {
+		if (isArray(keys)) {
+			keys = keys.filter((key) => {
+				return isString(key);
+			});
+		} else if (isString(keys)) {
+			keys = [keys];
+		} else if (!keys) {
+			keys = this.keys();
 		} else {
-			clear(key, callback);
+			throw new TypeError('Invalid argument');
 		}
+		keys.forEach((key) => {
+			delete this.promises[key];
+		});
 	}
@@ -155,0 +142,0 @@

lib/cp.js

 var fs = require('fs');
 var path = require('path');
-var async = require('async');
+var q = require('./q');
 var rm = require('./rm');
@@ -14,52 +14,39 @@ var mkdir = require('./mkdir');
  * @param  {String} to
- * @param  {Function} callback
- * @return {undefined}
+ * @return {Promise}
  */
-var cp = module.exports = function (from, to, callback) {
-	async.waterfall([
-		(callback) => {
-			async.parallel([
-				(callback) => {
-					fs.stat(from, callback);
-				},
-				(callback) => {
-					rm(to, callback);
-				}
-			], callback);
-		},
-		(results, callback) => {
-			var [stats] = results;
-			if (stats.isFile()) {
-				async.waterfall([
-					(callback) => {
-						mkdir(path.dirname(to), callback);
-					},
-					(callback) => {
-						log.info(from, '->', to);
-						fs.createReadStream(from)
-							.once('error', callback)
-							.pipe(fs.createWriteStream(to)
-								.once('finish', callback)
-								.once('error', callback));
-					}
-				], callback);
-			} else if (stats.isDirectory()) {
-				async.waterfall([
-					(callback) => {
-						mkdir(to, callback);
-					},
-					(callback) => {
-						fs.readdir(from, callback);
-					},
-					(files, callback) => {
-						async.each(files, (file, callback) => {
-							cp(path.join(from, file), path.join(to, file), callback);
-						}, callback);
-					}
-				], callback);
-			} else {
-				callback(new Error('unsupported filetype'));
-			}
+var cp = module.exports = function (from, to) {
+	return Promise.all([
+		q((callback) => {
+			fs.stat(from, callback);
+		}),
+		rm(to)
+	]).then((results) => {
+		var [stats] = results;
+		var promise;
+		if (stats.isFile()) {
+			promise = mkdir(path.dirname(to)).then(() => {
+				q((callback) => {
+					log.info(from, '->', to);
+					fs.createReadStream(from)
+						.once('error', callback)
+						.pipe(fs.createWriteStream(to)
+							.once('finish', callback)
+							.once('error', callback));
+				});
+			});
+		} else if (stats.isDirectory()) {
+			promise = mkdir(to).then(() => {
+				return q((callback) => {
+					fs.readdir(from, callback);
+				});
+			}).then((files) => {
+				return Promise.all(files.map((file) => {
+					return cp(path.join(from, file), path.join(to, file));
+				}));
+			});
+		} else {
+			promise = Promise.reject(new Error('unsupported filetype'));
 		}
-	], callback);
+		return promise;
+	});
 };

lib/mkdir.js

@@ -5,3 +5,3 @@ var EEXIST = 'EEXIST';
 var path = require('path');
-var async = require('async');
+var q = require('./q');
 var log = require('./log')('mkdir');
@@ -14,22 +14,25 @@
  * @param  {String} dir
- * @param  {Function} [callback]
+ * @return {Promise}
  */
-var mkdir = module.exports = function (dir, callback) {
-	async.waterfall([
-		(callback) => {
-			var parent = path.dirname(dir);
-			fs.mkdir(parent, (error) => {
-				switch (error && error.code) {
-					case ENOENT:
-						mkdir(parent, callback);
-						break;
-					case EEXIST:
-						/* jshint -W086 */
-						error = null;
-					default:
-						callback(error);
-				}
-			});
-		},
-		(callback) => {
+var mkdir = module.exports = function (dir) {
+	return new Promise((resolve, reject) => {
+		var parent = path.dirname(dir);
+		fs.mkdir(parent, (error) => {
+			switch (error && error.code) {
+				case ENOENT:
+					mkdir(parent).then(resolve, reject);
+					break;
+				case EEXIST:
+					/* jshint -W086 */
+					error = null;
+				default:
+					if (error) {
+						reject(error);
+					} else {
+						resolve();
+					}
+			}
+		});
+	}).then(() => {
+		return q((callback) => {
 			log.info(dir);
@@ -46,7 +49,6 @@ fs.mkdir(dir, (error) => {
 			});
-		},
-		(stats, callback) => {
-			callback(stats.isDirectory() ? null : new Error('EEXIST: file already exists, mkdir \'' + dir + '\''));
-		}
-	], callback);
+		});
+	}).then((stats) => {
+		return stats.isDirectory() ? null : Promise.reject(new Error('EEXIST: file already exists, mkdir \'' + dir + '\''));
+	});
 };

lib/rm.js

 var path = require('path');
 var fs = require('fs');
-var async = require('async');
 var log = require('./log')('rm');
+var q = require('./q');
 
@@ -11,37 +11,30 @@ /**
  * @param  {String} filepath
- * @param  {Function} callback
+ * @return {Promise}
  */
-var rm = function (filepath, callback) {
-	async.waterfall([
-		(callback) => {
-			fs.stat(filepath, (error, stat) => {
-				if (error) {
-					if (error.code === 'ENOENT') {
-						error = null;
-						stat = {
-							ENOENT: true
-						};
-					}
+var rm = function (filepath) {
+	return q((callback) => {
+		fs.stat(filepath, (error, stats) => {
+			if (error) {
+				if (error.code === 'ENOENT') {
+					error = null;
+					stats = {
+						ENOENT: true
+					};
 				}
-				callback(error, stat);
-			});
-		},
-		(stats, callback) => {
-			if (stats.ENOENT) {
-				callback();
-			} else if (stats.isDirectory()) {
-				async.waterfall([
-					(callback) => {
-						fs.readdir(filepath, callback);
-					},
-					(files, callback) => {
-						async.each(files, (file, callback) => {
-							rm(path.join(filepath, file), callback);
-						}, callback);
-					},
-					(callback) => {
-						log.info('[d]', filepath);
-						fs.rmdir(filepath, callback);
-					}
-				], callback);
+			}
+			callback(error, stats);
+		});
+	}).then((stats) => {
+		return stats.ENOENT ? null : q((callback) => {
+			if (stats.isDirectory()) {
+				q((callback) => {
+					fs.readdir(filepath, callback);
+				}).then((files) => {
+					return Promise.all(files.map((file) => {
+						return rm(path.join(filepath, file));
+					}), callback);
+				}, callback).then(() => {
+					log.info('[d]', filepath);
+					fs.rmdir(filepath, callback);
+				}, callback);
 			} else {
@@ -51,6 +44,6 @@ log.info('[f]', filepath);
 			}
-		}
-	], callback);
+		});
+	});
 };
 
 module.exports = rm;

lib/write-file.js

 var path = require('path');
 var fs = require('fs');
-var async = require('async');
+var q = require('./q');
 var mkdir = require('./mkdir');
@@ -14,14 +14,11 @@ var fileSize = require('./file-size');
  * @param  {Blob|String} data
- * @param  {Function} callback
+ * @return {Promise}
  */
-module.exports = function (to, data, callback) {
-	async.waterfall([
-		(callback) => {
-			mkdir(path.dirname(to), callback);
-		},
-		(callback) => {
+module.exports = function (to, data) {
+	return mkdir(path.dirname(to)).then(() => {
+		return q((callback) => {
 			log.info(to, fileSize(data.length));
 			fs.writeFile(to, data, callback);
-		}
-	], callback);
+		});
+	});
 };

package.json

 {
 	"name": "blogs_modules",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "utility functions for blogs",
@@ -14,5 +14,2 @@ "author": "Kei Ito",
 	},
-	"dependencies": {
-		"async": "*"
-	},
 	"devDependencies": {
@@ -19,0 +16,0 @@ "mocha": "*"

test/-cache.js

@@ -8,8 +8,20 @@ var assert = require('assert');
 		var cache = new Cache();
-		cache.get('E-liter 3K', (callback) => {
-			setTimeout(() => {
-				callback(null, 'Echolocator');
+		cache.get('E-liter 3K', () => {
+			return 'Echolocator';
+		}).then((value) => {
+			assert.equal(value, 'Echolocator');
+			done();
+		});
+	});
+
+	it('should accept asynchronous getter', function (done) {
+		var cache = new Cache();
+		cache.get('E-liter 3K', () => {
+			return new Promise((resolve) => {
+				setTimeout(() => {
+					resolve('Echolocator');
+				}, 10);
 			});
-		}, (error, value) => {
-			assert.equal(!error && value, 'Echolocator');
+		}).then((value) => {
+			assert.equal(value, 'Echolocator');
 			done();
@@ -19,16 +31,60 @@ });
 
+	it('should accept rejection', function (done) {
+		var cache = new Cache();
+		cache.get('E-liter 3K', () => {
+			throw 'Echolocator';
+		}).then(() => {
+			done(new Error('Unfortunately, it was resolved'));
+		}, (error) => {
+			assert.equal(error, 'Echolocator');
+			done();
+		});
+	});
+
+	it('should accept asynchronous rejection', function (done) {
+		var cache = new Cache();
+		cache.get('E-liter 3K', () => {
+			return new Promise((resolve, reject) => {
+				setTimeout(() => {
+					reject('Echolocator');
+				}, 10);
+			});
+		}).then(() => {
+			done(new Error('Unfortunately, it was resolved'));
+		}, (error) => {
+			assert.equal(error, 'Echolocator');
+			done();
+		});
+	});
+
+	it('should be retriable', function (done) {
+		var cache = new Cache();
+		cache.get('E-liter 3K', () => {
+			throw 'Echolocator';
+		}).then(() => {
+			done(new Error('Unfortunately, it was resolved'));
+		}, () => {
+			cache.get('E-liter 3K', () => {
+				return 'Splat Bombs';
+			}).then((value) => {
+				assert.equal(value, 'Splat Bombs');
+				done();
+			}, () => {
+				done(new Error('Unfortunately, it was rejected'));
+			});
+		});
+	});
+
 	it('should cache a value', function (done) {
 		var cache = new Cache();
 		var count = 0;
-		cache.get('Custom E-liter 3K', (callback) => {
-			setTimeout(() => {
-				callback(null, 'Kraken');
-			});
-		}, () => {});
-		cache.get('Custom E-liter 3K', (callback) => {
+		cache.get('Custom E-liter 3K', () => {
+			return 'Kraken';
+		});
+		cache.get('Custom E-liter 3K', () => {
 			count += 1;
-			callback(null, 'Squid Beakon');
-		}, (error, value) => {
+			return 'Squid Beakon';
+		}).then((value) => {
 			assert.deepEqual({
-				value: !error && value,
+				value: value,
 				count: count
@@ -45,18 +101,12 @@ }, {
 		var cache = new Cache();
-		cache.get('E-liter 3K Scope', (callback) => {
-			setTimeout(() => {
-				callback(null, 'Echolocator');
-			});
-		}, () => {});
-		cache.clear('E-liter 3K Scope', () => {
-			cache.get('E-liter 3K Scope', (callback) => {
-				callback(null, 'Splat Bombs');
-			}, (error, value) => {
-				assert.equal(!error && value, 'Splat Bombs');
-				done();
-			});
+		cache.get('E-liter 3K Scope', () => {
+			return 'Echolocator';
 		});
-		cache.get('E-liter 3K Scope', (callback) => {
-			callback(null, 'Echolocator');
-		}, () => {});
+		cache.clear('E-liter 3K Scope');
+		cache.get('E-liter 3K Scope', () => {
+			return 'Splat Bombs';
+		}).then((value) => {
+			assert.equal(value, 'Splat Bombs');
+			done();
+		});
 	});
@@ -66,14 +116,14 @@
 		var cache = new Cache();
-		cache.get('E-liter 3K', (callback) => {
-			callback(null, 'Echolocator');
-		}, () => {});
-		cache.get('Custom E-liter 3K', (callback) => {
-			callback(null, 'Kraken');
-		}, () => {});
-		cache.get('E-liter 3K Scope', (callback) => {
-			callback(null, 'Echolocator');
-		}, () => {});
-		cache.get('Custom E-liter 3K Scope', (callback) => {
-			callback(null, 'Kraken');
-		}, () => {});
+		cache.get('E-liter 3K', () => {
+			return 'Echolocator';
+		});
+		cache.get('Custom E-liter 3K', () => {
+			return 'Kraken';
+		});
+		cache.get('E-liter 3K Scope', () => {
+			return 'Echolocator';
+		});
+		cache.get('Custom E-liter 3K Scope', () => {
+			return 'Kraken';
+		});
 		assert.deepEqual(cache.keys(), [
@@ -87,20 +137,18 @@ 'E-liter 3K',
 
-	it('should clear all', function (done) {
+	it('should clear all', function () {
 		var cache = new Cache();
-		cache.get('E-liter 3K', (callback) => {
-			callback(null, 'Echolocator');
-		}, () => {});
-		cache.get('Custom E-liter 3K', (callback) => {
-			callback(null, 'Kraken');
-		}, () => {});
-		cache.get('E-liter 3K Scope', (callback) => {
-			callback(null, 'Echolocator');
-		}, () => {});
-		cache.get('Custom E-liter 3K Scope', (callback) => {
-			callback(null, 'Kraken');
-		}, () => {});
-		cache.clear(null, () => {
-			assert.deepEqual(cache.keys(), []);
-			done();
+		cache.get('E-liter 3K', () => {
+			return 'Echolocator';
 		});
+		cache.get('Custom E-liter 3K', () => {
+			return 'Kraken';
+		});
+		cache.get('E-liter 3K Scope', () => {
+			return 'Echolocator';
+		});
+		cache.get('Custom E-liter 3K Scope', () => {
+			return 'Kraken';
+		});
+		cache.clear();
+		assert.deepEqual(cache.keys(), []);
 	});
@@ -110,10 +158,10 @@
 		var cache = new Cache(0.03);
-		cache.get('E-liter 3K', (callback) => {
-			callback(null, 'Echolocator', 0.01);
-		}, () => {});
+		cache.get('E-liter 3K', () => {
+			return 'Echolocator';
+		}, 0.01);
 		setTimeout(() => {
-			cache.get('E-liter 3K', (callback) => {
-				callback(null, 'Splat Bombs');
-			}, (error, value) => {
-				assert.equal(!error && value, 'Splat Bombs');
+			cache.get('E-liter 3K', () => {
+				return 'Splat Bombs';
+			}).then((value) => {
+				assert.equal(value, 'Splat Bombs');
 				done();
@@ -127,10 +175,10 @@ });
 		cache.stop();
-		cache.get('E-liter 3K', (callback) => {
-			callback(null, 'Echolocator', 0.01);
-		}, () => {});
+		cache.get('E-liter 3K', () => {
+			return 'Echolocator';
+		}, 0.01);
 		setTimeout(() => {
-			cache.get('E-liter 3K', (callback) => {
-				callback(null, 'Splat Bombs');
-			}, (error, value) => {
-				assert.equal(!error && value, 'Echolocator');
+			cache.get('E-liter 3K', () => {
+				return 'Splat Bombs';
+			}).then((value) => {
+				assert.equal(value, 'Echolocator');
 				done();
@@ -137,0 +185,0 @@ });

test/cp.js

 var fs = require('fs');
 var path = require('path');
 var assert = require('assert');
-var async = require('async');
+var q = require('../lib/q');
 var cp = require('../lib/cp');
@@ -13,35 +13,28 @@ var rm = require('../lib/rm');
 	beforeEach(function (done) {
-		rm(baseDir, done);
+		rm(baseDir).then(done, done);
 	});
 
 	afterEach(function (done) {
-		rm(baseDir, done);
+		rm(baseDir).then(done, done);
 	});
 
 	it('should copy files', function (done) {
+		var libDir = path.join(__dirname, '../lib');
 		var originalFiles;
-		async.waterfall([
-			(callback) => {
-				var libDir = path.join(__dirname, '../lib');
-				async.parallel([
-					(callback) => {
-						cp(libDir, baseDir, callback);
-					},
-					(callback) => {
-						fs.readdir(libDir, callback);
-					}
-				], callback);
-			},
-			(results, callback) => {
-				originalFiles = results[1];
+		Promise.all([
+			q((callback) => {
+				fs.readdir(libDir, callback);
+			}),
+			cp(libDir, baseDir)
+		]).then((results) => {
+			[originalFiles] = results;
+			return q((callback) => {
 				fs.readdir(baseDir, callback);
-			},
-			(files, callback) => {
-				assert.deepEqual(originalFiles, files);
-				callback();
-			}
-		], done);
-
+			});
+		}).then((files) => {
+			assert.deepEqual(originalFiles, files);
+			done();
+		}, done);
 	});
 
 });

test/mkdir.js

 var path = require('path');
 var fs = require('fs');
 var assert = require('assert');
-var async = require('async');
+var q = require('../lib/q');
 var rm = require('../lib/rm');
@@ -13,18 +13,14 @@ var mkdir = require('../lib/mkdir');
 	after(function (done) {
-		rm(baseDir, done);
+		rm(baseDir).then(done, done);
 	});
 
 	it('should create a directory', function (done) {
-		async.waterfall([
-			(callback) => {
-				mkdir(baseDir, callback);
-			},
-			(callback) => {
+		mkdir(baseDir).then(() => {
+			return q((callback) => {
 				fs.stat(baseDir, callback);
-			},
-			(stats, callback) => {
+			}).then((stats) => {
 				assert.equal(stats.isDirectory(), true);
-				callback();
-			}
-		], done);
+				done();
+			}, done);
+		});
 	});
@@ -34,14 +30,10 @@
 		var target = path.join(baseDir, 'a/b/c/d/e/f');
-		async.waterfall([
-			(callback) => {
-				mkdir(target, callback);
-			},
-			(callback) => {
+		mkdir(target).then(() => {
+			return q((callback) => {
 				fs.stat(target, callback);
-			},
-			(stats, callback) => {
-				assert.equal(stats.isDirectory(), true);
-				callback();
-			}
-		], done);
+			});
+		}).then((stats) => {
+			assert.equal(stats.isDirectory(), true);
+			done();
+		}, done);
 	});
@@ -51,21 +43,17 @@
 		var target = path.join(baseDir, 'a/b/c/d/e/f');
-		async.waterfall([
-			(callback) => {
-				async.each([
-					target,
-					target
-				], function (target, callback) {
-					mkdir(target, callback);
-				}, callback);
-			},
-			(callback) => {
+		Promise.all([
+			target,
+			target
+		].map((target) => {
+			return mkdir(target);
+		})).then(() => {
+			return q((callback) => {
 				fs.stat(target, callback);
-			},
-			(stats, callback) => {
-				assert.equal(stats.isDirectory(), true);
-				callback();
-			}
-		], done);
+			});
+		}).then((stats) => {
+			assert.equal(stats.isDirectory(), true);
+			done();
+		}, done);
 	});
 
 });

test/rm.js

 var assert = require('assert');
 var path = require('path');
 var fs = require('fs');
-var async = require('async');
 var rm = require('../lib/rm');
+var q = require('../lib/q');
 
@@ -24,28 +24,24 @@ var existOK = function (callback) {
 	before(function (done) {
-		async.waterfall([
-			(callback) => {
-				fs.mkdir(baseDir, existOK(callback));
-			},
-			(callback) => {
-				async.parallel([
-					(callback) => {
-						fs.writeFile(file, file, existOK(callback));
-					},
-					(callback) => {
-						fs.mkdir(emptyDir, existOK(callback));
-					},
-					(callback) => {
-						async.waterfall([
-							(callback) => {
-								fs.mkdir(notEmptyDir, existOK(callback));
-							},
-							(callback) => {
-								var target = path.join(notEmptyDir, 'not-empty-dir.txt');
-								fs.writeFile(target, target, existOK(callback));
-							}
-						], callback);
-					}
-				], callback);
-			}
-		], done);
+		q((callback) => {
+			fs.mkdir(baseDir, existOK(callback));
+		}).then((() => {
+			return Promise.all([
+				q((callback) => {
+					fs.writeFile(file, file, existOK(callback));
+				}),
+				q((callback) => {
+					fs.mkdir(emptyDir, existOK(callback));
+				}),
+				q((callback) => {
+					fs.mkdir(notEmptyDir, existOK(callback));
+				}).then(() => {
+					return q((callback) => {
+						var target = path.join(notEmptyDir, 'not-empty-dir.txt');
+						fs.writeFile(target, target, existOK(callback));
+					});
+				})
+			]);
+		})).then(() => {
+			done();
+		});
 	});
@@ -58,40 +54,28 @@
 	it('should delete a file', function (done) {
-		rm(file, (error) => {
-			if (error) {
-				throw error;
-			} else {
-				fs.stat(file, (error) => {
-					assert.equal(error.code, 'ENOENT');
-					done();
-				});
-			}
-		});
+		rm(file).then(() => {
+			fs.stat(file, (error) => {
+				assert.equal(error.code, 'ENOENT');
+				done();
+			});
+		}, done);
 	});
 
 	it('should delete an empty directory', function (done) {
-		rm(emptyDir, (error) => {
-			if (error) {
-				throw error;
-			} else {
-				fs.stat(emptyDir, (error) => {
-					assert.equal(error.code, 'ENOENT');
-					done();
-				});
-			}
-		});
+		rm(emptyDir).then(() => {
+			fs.stat(emptyDir, (error) => {
+				assert.equal(error.code, 'ENOENT');
+				done();
+			});
+		}, done);
 	});
 
 	it('should delete a directory', function (done) {
-		rm(notEmptyDir, (error) => {
-			if (error) {
-				throw error;
-			} else {
-				fs.stat(notEmptyDir, (error) => {
-					assert.equal(error.code, 'ENOENT');
-					done();
-				});
-			}
-		});
+		rm(notEmptyDir).then(() => {
+			fs.stat(notEmptyDir, (error) => {
+				assert.equal(error.code, 'ENOENT');
+				done();
+			});
+		}, done);
 	});
 
 });

test/write-file.js

 var path = require('path');
 var fs = require('fs');
 var assert = require('assert');
-var async = require('async');
+var q = require('../lib/q');
 var writeFile = require('../lib/write-file');
@@ -13,7 +13,7 @@ var rm = require('../lib/rm');
 	beforeEach(function (done) {
-		rm(baseDir, done);
+		rm(baseDir).then(done, done);
 	});
 
 	afterEach(function (done) {
-		rm(baseDir, done);
+		rm(baseDir).then(done, done);
 	});
@@ -24,19 +24,10 @@
 		var data = Buffer.from(target);
-		async.waterfall([
-			function (callback) {
-				writeFile(target, data, callback);
-			},
-			function (callback) {
+		writeFile(target, data).then(() => {
+			return q((callback) => {
 				fs.stat(target, callback);
-			},
-			function (stats, callback) {
-				assert.equal(stats.size, data.length);
-				callback();
-			}
-		], function (error) {
-			if (error) {
-				throw error;
-			}
+			});
+		}).then((stats) => {
+			assert.equal(stats.size, data.length);
 			done();
-		});
+		}, done);
 	});
@@ -53,27 +44,18 @@
 		});
-		async.waterfall([
-			function (callback) {
-				async.each(files, function (target, callback) {
-					writeFile(target, data, callback);
-				}, callback);
-			},
-			function (callback) {
-				async.map(files, function (target, callback) {
+		Promise.all(files.map((target) => {
+			return writeFile(target, data);
+		})).then(() => {
+			return Promise.all(files.map((target) => {
+				return q((callback) => {
 					fs.stat(target, callback);
-				}, callback);
-			},
-			function (stats, callback) {
-				assert.equal(stats.reduce(function (size, stats) {
-					return size + stats.size;
-				}, 0), data.length * files.length);
-				callback();
-			}
-		], function (error) {
-			if (error) {
-				throw error;
-			}
+				});
+			}));
+		}).then((results) => {
+			assert.equal(results.reduce((size, stats) => {
+				return size + (stats.isFile() ? stats.size : 0);
+			}, 0), data.length * files.length);
 			done();
-		});
+		}, done);
 	});
 
 });

Fixed alerts

Wildcard dependency

Quality

Package has a dependency with a floating version range. This can cause issues if the dependency publishes a new major version.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

42015

4.55%

Dependency count

0

-100%

Number of package files

54

8%

Lines of code

1647

3.65%

Number of medium quality alerts

1

-50%

Dependency changes

• - Removed

  async@*

• - Removed

  async@3.2.6
  (transitive)