Implement asyncMap function

Closes: #391
PR-URL: #387

Author: ivan-tymoshenko

lib/array.js

@@ -38,6 +38,69 @@ const map = (
   }
 };
 
+const DEFAULT_OPTIONS = { min: 5, percent: 0.7 };
+
+// Non-blocking synchronous map
+//   items - <Array>, incoming dataset
+//   fn - <Function>
+//     item - <any>
+//     index - <number>
+//   options - <Object>, map params { min, percent }
+//     min - <number>, min number of items in one next call
+//     percent - <number>, ratio of map time to all time
+//   done - <Function>, call on done
+//     err - <Error> | <null>
+//     result - <Array>
+const asyncMap = (items, fn, options = {}, done) => {
+  if (typeof options === 'function') {
+    done = options;
+    options = DEFAULT_OPTIONS;
+  }
+
+  if (!items.length) {
+    if (done) done(null, []);
+    return;
+  }
+
+  const min = options.min || DEFAULT_OPTIONS.min;
+  const percent = options.percent || DEFAULT_OPTIONS.percent;
+
+  let begin;
+  let sum = 0;
+  let count = 0;
+
+  const result = done ? new Array(items.length) : null;
+  const ratio = percent / (1 - percent);
+
+  const countNumber = () => {
+    const loopTime = Date.now() - begin;
+    const itemTime = sum / count;
+    const necessaryNumber = ratio * loopTime / itemTime;
+    return Math.max(necessaryNumber, min);
+  };
+
+  const next = () => {
+    const itemsNumber = count ? countNumber() : min;
+    const iterMax = Math.min(items.length, itemsNumber + count);
+
+    begin = Date.now();
+    for (; count < iterMax; count++) {
+      const itemResult = fn(items[count], count);
+      if (done) result[count] = itemResult;
+    }
+    sum += Date.now() - begin;
+
+    if (count < items.length) {
+      begin = Date.now();
+      setTimeout(next, 0);
+    } else if (done) {
+      done(null, result);
+    }
+  };
+
+  next();
+};
+
 const filter = (
   // Asynchrous filter (iterate parallel)
   items, // array, incoming
@@ -303,4 +366,5 @@ module.exports = {
   find,
   every,
   some,
+  asyncMap,
 };

test/array.asyncMap.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const metasync = require('..');
+const metatests = require('metatests');
+
+metatests.test('succesfull map', test => {
+  test.plan(2);
+
+  const arr = [1, 2, 3];
+  const expectedArr = [2, 4, 6];
+
+  metasync.asyncMap(arr, item => item * 2, (err, newArr) => {
+    test.error(err);
+    test.strictSame(newArr, expectedArr);
+  });
+});
+
+const doSmth = time => {
+  const begin = Date.now();
+  while (Date.now() - begin < time);
+};
+
+metatests.test('Non-blocking', test => {
+  const ARRAY_SIZE = 1000;
+  const MIN_IO_CALLS = 90;
+  const MAX_IO_CALLS = 110;
+
+  let ioCallsCount = 0;
+  const arr = new Array(ARRAY_SIZE).fill(1);
+
+  const timer = setInterval(() => {
+    doSmth(9);
+    ioCallsCount++;
+  }, 1);
+
+  metasync.asyncMap(arr, () => doSmth(1),
+    { percent: 0.5 }, () => {
+      clearInterval(timer);
+      test.assert(ioCallsCount >= MIN_IO_CALLS);
+      test.assert(ioCallsCount <= MAX_IO_CALLS);
+      test.end();
+    });
+});
+