refactor into simpler code and API

Author: grindcode

index.js

@@ -1,36 +1,36 @@
-module.exports = function (fn, lever, opts) {
-  var stress = 1
-  var cycle
-  var options = Object.assign({
-    modifier: 1.20, timeout: 1000, min: 1, max: 0
-  }, opts)
-  var increase = function () {
-    var s = stress * options.modifier
-    return (s < options.max || !options.max)? s: options.max
-  }
-  var decrease = function () {
-    var s = stress / options.modifier
-    return (s > options.min)? s: options.min
-  }
-  var balance = function () {
-    var s = stress
-    stress = (lever())? increase(): decrease()
-    return stress !== s
-  }
-  var end = function () {
-    clearInterval(cycle)
-  }
-  var run = function () {
-    var timeout = options.timeout * stress
-    var runInterval = function () {
-      fn({ stress: stress, timeout: timeout })
-      if (balance()) run()
+module.exports = function (fn, relay, options = {}) {
+    const {modifier = 1.20, timeout = 1000, min = 1, max = 0} = options
+    let stress = 1
+    let cycle
+    function increase () {
+        const nextStress = stress * modifier
+        return (nextStress < max || !max) ? nextStress : max
     }
-    end()
-    cycle = setInterval(runInterval, timeout)
-  }
-  run()
-  return {
-    end: end
-  }
+    function decrease () {
+        const nextStress = stress / modifier
+        return nextStress > min ? nextStress : min
+    }
+    function balance () {
+        const prevStress = stress
+        stress = relay() ? increase() : decrease()
+        return prevStress !== stress
+    }
+    function start (nextTimeout) {
+        cycle = setInterval(run, nextTimeout)
+    }
+    function run () {
+        const nextTimeout = timeout * stress
+        fn({stress, timeout: nextTimeout, cycle})
+        if (balance()) {
+            clear()
+            start(nextTimeout)
+        }
+    }
+    function clear () {
+        if (cycle) {
+            clearInterval(cycle)
+        }
+    }
+    start()
+    return clear
 }

test/cycle.js

@@ -2,69 +2,62 @@ var test = require('tape')
 var loop = require('../index.js')
 
 test('cycle defaults', function (t) {
-  t.plan(10)
-  var runs = 0
-  var busy = true
-  var cycle
-  var validate = function (f) {
-    switch (runs) {
-      case 0: t.equal(f.timeout, 1000); break
-      case 1: t.equal(f.timeout, 1200); break
-      case 2: t.equal(f.timeout, 1440); break
-      case 3: t.equal(f.timeout, 1728); break
-      case 4: t.equal(f.timeout, 2073.6); break
-      case 5: t.equal(f.timeout, 1728); break
-      case 6: t.equal(f.timeout, 1440); break
-      case 7: t.equal(f.timeout, 1200); break
-      case 8: t.equal(f.timeout, 1000); break
-      case 9: t.equal(f.timeout, 1000); break
+    t.plan(10)
+    let runs = 0
+    function validate (f) {
+        switch (runs) {
+            case 0: t.equal(f.timeout, 1000); break
+            case 1: t.equal(f.timeout, 1200); break
+            case 2: t.equal(f.timeout, 1440); break
+            case 3: t.equal(f.timeout, 1728); break
+            case 4: t.equal(f.timeout, 2073.6); break
+            case 5: t.equal(f.timeout, 1728); break
+            case 6: t.equal(f.timeout, 1440); break
+            case 7: t.equal(f.timeout, 1200); break
+            case 8: t.equal(f.timeout, 1000); break
+            case 9: t.equal(f.timeout, 1000); break
+        }
     }
-  }
-  var execute = function (f) {
-    if (runs === 10) {
-      cycle.end()
-      t.end()
+    function execute (f) {
+        if (runs === 10) {
+            clearLoop()
+            t.end()
+        }
+        else {
+            validate(f)
+            runs++
+        }
     }
-    else {
-      validate(f)
-      runs++
-    }
-  }
-  cycle = loop(execute, function () {
-    return runs < 5
-  })
+    let clearLoop = loop(execute, () => runs < 5)
 })
 
 test('cycle with max', function (t) {
-  t.plan(10)
-  var runs = 0
-  var busy = true
-  var cycle
-  var validate = function (f) {
-    switch (runs) {
-      case 0: t.equal(f.timeout, 10); break
-      case 1: t.equal(f.timeout, 20); break
-      case 2: t.equal(f.timeout, 40); break
-      case 3: t.equal(f.timeout, 40); break
-      case 4: t.equal(f.timeout, 40); break
-      case 5: t.equal(f.timeout, 20); break
-      case 6: t.equal(f.timeout, 10); break
-      case 7: t.equal(f.timeout, 10); break
-      case 8: t.equal(f.timeout, 10); break
-      case 9: t.equal(f.timeout, 10); break
-    }
-  }
-  var execute = function (f) {
-    if (runs === 10) {
-      cycle.end()
-      t.end()
+    t.plan(10)
+    let runs = 0
+    function validate (f) {
+        switch (runs) {
+            case 0: t.equal(f.timeout, 10); break
+            case 1: t.equal(f.timeout, 20); break
+            case 2: t.equal(f.timeout, 40); break
+            case 3: t.equal(f.timeout, 40); break
+            case 4: t.equal(f.timeout, 40); break
+            case 5: t.equal(f.timeout, 20); break
+            case 6: t.equal(f.timeout, 10); break
+            case 7: t.equal(f.timeout, 10); break
+            case 8: t.equal(f.timeout, 10); break
+            case 9: t.equal(f.timeout, 10); break
+        }
     }
-    else {
-      validate(f)
-      runs++
+    function execute (f) {
+        if (runs === 10) {
+            clearInterval(f.cycle)
+            t.end()
+        }
+        else {
+            validate(f)
+            runs++
+        }
     }
-  }
-  cycle = loop(execute, function () {
-    return runs < 5
-  }, { timeout: 10, max: 4, modifier: 2 })
+    const options = {timeout: 10, max: 4, modifier: 2}
+    loop(execute, () => runs < 5, options)
 })