breaking: remove during, make test functions in until/whilst async

lib/doUntil.js

@@ -1,4 +1,5 @@
 import doWhilst from './doWhilst';
+import wrapAsync from './internal/wrapAsync';
 
 /**
  * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the
@@ -12,14 +13,18 @@ import doWhilst from './doWhilst';
  * @category Control Flow
  * @param {AsyncFunction} iteratee - An async function which is called each time
  * `test` fails. Invoked with (callback).
- * @param {Function} test - synchronous truth test to perform after each
- * execution of `iteratee`. Invoked with any non-error callback results of
- * `iteratee`.
+ * @param {Function} test - asynchronous truth test to perform after each
+ * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the
+ * non-error args from the previous callback of `fn`
  * @param {Function} [callback] - A callback which is called after the test
  * function has passed and repeated execution of `iteratee` has stopped. `callback`
  * will be passed an error and any arguments passed to the final `iteratee`'s
  * callback. Invoked with (err, [results]);
  */
 export default function doUntil(iteratee, test, callback) {
-    doWhilst(iteratee, (...args) => !test(...args), callback);
+    const _test = wrapAsync(test)
+    doWhilst(iteratee, (...args) => {
+        const cb = args.pop()
+        _test(...args, (err, truth) => cb (err, !truth))
+    }, callback);
 }

lib/doWhilst.js

@@ -17,22 +17,34 @@ import wrapAsync from './internal/wrapAsync';
  * @category Control Flow
  * @param {AsyncFunction} iteratee - A function which is called each time `test`
  * passes. Invoked with (callback).
- * @param {Function} test - synchronous truth test to perform after each
- * execution of `iteratee`. Invoked with any non-error callback results of
- * `iteratee`.
+ * @param {Function} test - asynchronous truth test to perform after each
+ * execution of `iteratee`. Invoked with (...args, callback), where `...args` are the
+ * non-error args from the previous callback of `fn`.
  * @param {Function} [callback] - A callback which is called after the test
  * function has failed and repeated execution of `iteratee` has stopped.
  * `callback` will be passed an error and any arguments passed to the final
  * `iteratee`'s callback. Invoked with (err, [results]);
+ * @return undefined
  */
 export default function doWhilst(iteratee, test, callback) {
     callback = onlyOnce(callback || noop);
-    var _iteratee = wrapAsync(iteratee);
-    function next (err, ...args) {
+    var _fn = wrapAsync(iteratee);
+    var _test = wrapAsync(test);
+    var results
+
+    function next(err, ...args) {
+        if (err) return callback(err);
+        if (err === false) return;
+        results = args
+        _test(...args, check);
+    }
+
+    function check(err, truth) {
         if (err) return callback(err);
         if (err === false) return;
-        if (test(...args)) return _iteratee(next);
-        callback(null, ...args);
+        if (!truth) return callback(null, ...results);
+        _fn(next);
     }
-    _iteratee(next);
+
+    return check(null, true);
 }

lib/index.js

@@ -79,10 +79,8 @@ import detect from './detect'
 import detectLimit from './detectLimit'
 import detectSeries from './detectSeries'
 import dir from './dir'
-import doDuring from './doDuring'
 import doUntil from './doUntil'
 import doWhilst from './doWhilst'
-import during from './during'
 import each from './each'
 import eachLimit from './eachLimit'
 import eachOf from './eachOf'
@@ -158,10 +156,8 @@ export default {
     detectLimit,
     detectSeries,
     dir,
-    doDuring,
     doUntil,
     doWhilst,
-    during,
     each,
     eachLimit,
     eachOf,
@@ -262,10 +258,8 @@ export {
     detectLimit as detectLimit,
     detectSeries as detectSeries,
     dir as dir,
-    doDuring as doDuring,
     doUntil as doUntil,
     doWhilst as doWhilst,
-    during as during,
     each as each,
     eachLimit as eachLimit,
     eachOf as eachOf,

lib/until.js

@@ -1,4 +1,5 @@
 import whilst from './whilst';
+import wrapAsync from './internal/wrapAsync';
 
 /**
  * Repeatedly call `iteratee` until `test` returns `true`. Calls `callback` when
@@ -13,15 +14,30 @@ import whilst from './whilst';
  * @method
  * @see [async.whilst]{@link module:ControlFlow.whilst}
  * @category Control Flow
- * @param {Function} test - synchronous truth test to perform before each
- * execution of `iteratee`. Invoked with ().
+ * @param {Function} test - asynchronous truth test to perform before each
+ * execution of `iteratee`. Invoked with (callback).
  * @param {AsyncFunction} iteratee - An async function which is called each time
  * `test` fails. Invoked with (callback).
  * @param {Function} [callback] - A callback which is called after the test
  * function has passed and repeated execution of `iteratee` has stopped. `callback`
  * will be passed an error and any arguments passed to the final `iteratee`'s
  * callback. Invoked with (err, [results]);
+ *
+ * @example
+ * const results = []
+ * async.until(function iter(next) {
+ *     fetchPage(url, (err, body) => {
+ *         if (err) return next(err)
+ *         results = results.concat(body.objects)
+ *         next(err, body)
+ *     })
+ * }, function test(page, cb) {
+ *     cb(null, page.next == null)
+ * }, function done (err) {
+ *     // all pages have been fetched
+ * })
  */
 export default function until(test, iteratee, callback) {
-    whilst((...args) => !test(...args), iteratee, callback);
+    const _test = wrapAsync(test)
+    whilst((cb) => _test((err, truth) => cb (err, !truth)), iteratee, callback);
 }

lib/whilst.js

@@ -12,7 +12,7 @@ import wrapAsync from './internal/wrapAsync';
  * @memberOf module:ControlFlow
  * @method
  * @category Control Flow
- * @param {Function} test - synchronous truth test to perform before each
+ * @param {AsyncFunction} test - asynchronous truth test to perform before each
  * execution of `iteratee`. Invoked with ().
  * @param {AsyncFunction} iteratee - An async function which is called each time
  * `test` passes. Invoked with (callback).
@@ -25,8 +25,8 @@ import wrapAsync from './internal/wrapAsync';
  *
  * var count = 0;
  * async.whilst(
- *     function() { return count < 5; },
- *     function(callback) {
+ *     function test(cb) { cb(null, count < 5;) },
+ *     function iter(callback) {
  *         count++;
  *         setTimeout(function() {
  *             callback(null, count);
@@ -39,13 +39,23 @@ import wrapAsync from './internal/wrapAsync';
  */
 export default function whilst(test, iteratee, callback) {
     callback = onlyOnce(callback || noop);
-    var _iteratee = wrapAsync(iteratee);
-    if (!test()) return callback(null);
-    var next = (err, ...args) => {
+    var _fn = wrapAsync(iteratee);
+    var _test = wrapAsync(test);
+    var results
+
+    function next(err, ...rest) {
         if (err) return callback(err);
+        results = rest;
         if (err === false) return;
-        if (test()) return _iteratee(next);
-        callback(null, ...args);
-    };
-    _iteratee(next);
+        _test(check);
+    }
+
+    function check(err, truth) {
+        if (err) return callback(err);
+        if (err === false) return;
+        if (!truth) return callback(null, ...results);
+        _fn(next);
+    }
+
+    return _test(check);
 }