Use Infinity in retry. Do not fail on returned Error. Update README.

Author: calvinwiebe

README.md

@@ -42,6 +42,7 @@ Then somewhere in your node.js application:
 * [`series`](#series)
 * [`timeout`](#timeout)
 * [`whilst`](#whilst), `doWhilst`
+* [`retry`](#retry)
 
 
 # Utilities
@@ -161,3 +162,37 @@ Example:
     .then(function(result) {
        // result will be 10 here.
     });
+
+<a name="retry"/>
+### retry(options, fn)
+
+Will continuously call `fn` until it returns a synchronous value, doesn't throw, or returns a Promise that resolves. It will be retried `options.times`. You can pass `{times: Infinity}` to retry indefinitely. The `fn` will be passed the `lastAttempt` object which is the Error object of the last attempt.
+
+Options: `times` (Default=5) and `interval` (Default=0). `interval` is the time between retries in milliseconds. If the `options` argument is passed as just a number, only `times` will be set.
+
+Examples:
+
+    var count = 0;
+    promiseTools.retry({times: 4, interval: 5}, function(lastAttempt) {
+        count++;
+        if (count === 2) Promise.resolve(true);
+        else Promise.reject(new Error('boom'));
+    })
+    .then(function(result) {
+       // result will be `true` here.
+    });
+
+    ---------------------------------------------
+
+    var count = 0;
+    promiseTools.retry(1, function(lastAttempt) {
+        count++;
+        if (count === 2) Promise.resolve(true);
+        else Promise.reject(new Error('boom'));
+    })
+    .then(function(result) {
+       // will not resolve.
+    })
+    .catch(function(err) {
+        // err.message should be `boom` here.
+    });

src/index.js

@@ -191,8 +191,6 @@ exports.doWhilst = (fn, test) => {
     return exports.whilst(doTest, fn);
 };
 
-exports.FOREVER = -1;
-
 /*
  * keep calling `fn` until it returns a non-error value, doesn't throw, or returns a Promise that resolves. `fn` will be
  * attempted `times` many times before rejecting. If `times` is given as `exports.FOREVER`, then `retry` will attempt to
@@ -206,8 +204,8 @@ exports.FOREVER = -1;
 exports.retry = (options, fn) => {
     let times = 5;
     let interval = 0;
-    let attempts = [];
-    let infinite = false;
+    let attempts = 0;
+    let lastAttempt = null;
 
     if ('number' === typeof(options)) {
         times = options;
@@ -220,22 +218,18 @@ exports.retry = (options, fn) => {
         throw new Error('Unsupported argument type for \'times\': ' + typeof(options));
     }
 
-    if (times === exports.FOREVER) infinite = true;
-
     return new Promise((resolve, reject) => {
         let doIt = () => {
             Promise.resolve()
             .then(() => {
-                return fn(attempts[attempts.length - 1]);
-            })
-            .then((results) => {
-                if (results instanceof Error) throw results;
-                else resolve(results);
+                return fn(lastAttempt);
             })
+            .then(resolve)
             .catch((err) => {
-                attempts.push(err);
-                if (!infinite && attempts.length === times) {
-                    reject(attempts);
+                attempts++;
+                lastAttempt = err;
+                if (times !== Infinity && attempts === times) {
+                    reject(lastAttempt);
                 } else {
                     setTimeout(doIt, interval);
                 }

test/retry.js

@@ -20,15 +20,15 @@ describe('retry', () => {
     });
 
     it('should retry infinitely and resolve', () => {
-        let retry = promiseTools.retry(-1, getTest(3));
+        let retry = promiseTools.retry(Infinity, getTest(3));
         return expect(retry).to.eventually.equal(3);
     });
 
     it('should reject', (done) => {
         let retry = promiseTools.retry(3, getTest(4));
-        retry.catch((attempts) => {
+        retry.catch((lastAttempt) => {
             try {
-                expect(attempts.length).to.eq(3);
+                expect(lastAttempt).to.be.instanceof(Error);
                 done();
             } catch (err) {
                 done(err);
@@ -58,12 +58,4 @@ describe('retry', () => {
         });
         expect(p).to.eventually.be.rejectedWith('Unsupported argument type for \'times\': undefined');
     });
-
-    it('should reject when an Error value is resolved', () => {
-        let retry = promiseTools.retry(1, () => {
-            return new Error('boom');
-        });
-        return expect(retry).to.eventually.be.rejectedWith('boom');
-    });
-
 });