fixup! Use eslint-config-metarhia and fix linting issues

lib/chain.js

@@ -11,7 +11,9 @@ const async = op => {
     case 'series': return series;
     case 'find': return find;
   }
-  return null;
+  return (items, fn, callback) => {
+    callback(null, items.slice());
+  };
 };
 
 function ArrayChain(array) {

lib/collector.functor.js

@@ -25,12 +25,12 @@ const collect = expected => {
   const collector = (key, err, value) => {
     if (isDone) return collector;
     if (!isDistinct || !(key in data)) {
-      if (!isCount && !keys.has(key)) return null;
+      if (!isCount && !keys.has(key)) return collector;
       count++;
     }
     if (err) {
       collector.finalize(err, data);
-      return null;
+      return collector;
     }
     data[key] = value;
     if (expected === count) {

lib/fp.js

@@ -28,9 +28,7 @@ const asAsync = (
 const of = (
   // Hint: pure :: Applicative f => a -> f a
   ...args // array
-) => (
-  asAsync(callback => callback(null, ...args))
-);
+) => asAsync(callback => callback(null, ...args));
 
 const concat = (
   // Hint: concat :: Monoid m => a -> a -> a
@@ -57,9 +55,7 @@ const ap = (
   // Hint: <*> :: Applicative f => f (a -> b) -> f a -> f b
   fn, // function
   funcA // function
-) => (
-  concat(funcA, (f, callback) => fmap(fn, f)(callback))
-);
+) => concat(funcA, (f, callback) => fmap(fn, f)(callback));
 
 asyncChainMethods = { fmap, ap, concat };
 

lib/poolify.js

@@ -18,7 +18,7 @@ const poolify = (factory, min, norm, max) => {
         if (delayed) delayed(item);
         else pool.items.push(item);
       }
-      return undefined;
+      return pool;
     }
     if (pool.items.length < min && allocated < max) {
       const grow = Math.min(max - allocated, norm - pool.items.length);
@@ -31,7 +31,7 @@ const poolify = (factory, min, norm, max) => {
     const callback = provide(par);
     if (res) callback(res);
     else pool.delayed.push(callback);
-    return undefined;
+    return pool;
   };
   return Object.assign(pool, {
     items: duplicate(factory, norm),

lib/poolify.opt.js

@@ -12,15 +12,15 @@ const poolify = (factory, min, norm, max) => {
   let allocated = norm;
   const items = duplicate(factory, norm);
   const delayed = [];
-  return par => {
+  const pool = par => {
     if (Array.isArray(par)) {
       while (par.length) {
         const item = par.shift();
         const request = delayed.shift();
         if (request) request(item);
         else items.push(item);
       }
-      return undefined;
+      return pool;
     }
     if (items.length < min && allocated < max) {
       const grow = Math.min(max - allocated, norm - items.length);
@@ -33,8 +33,9 @@ const poolify = (factory, min, norm, max) => {
     const callback = provide(par);
     if (res) callback(res);
     else delayed.push(callback);
-    return undefined;
+    return pool;
   };
+  return pool;
 };
 
 module.exports = { poolify };

lib/poolify.symbol.js

@@ -21,7 +21,7 @@ const poolify = (factory, min, norm, max) => {
       const delayed = pool.delayed.shift();
       if (delayed) delayed(par);
       else pool.items.push(par);
-      return undefined;
+      return pool;
     }
     if (pool.items.length < min && allocated < max) {
       const grow = Math.min(max - allocated, norm - pool.items.length);
@@ -34,7 +34,7 @@ const poolify = (factory, min, norm, max) => {
     const callback = provide(par);
     if (res) callback(res);
     else pool.delayed.push(callback);
-    return undefined;
+    return pool;
   };
   return Object.assign(pool, {
     items: duplicate(factory, norm),

package.json

@@ -52,7 +52,7 @@
     "babel-cli": "^6.26.0",
     "babel-preset-env": "^1.7.0",
     "eslint": "^5.7.0",
-    "eslint-config-metarhia": "^5.0.0",
+    "eslint-config-metarhia": "^6.0.0",
     "eslint-plugin-import": "^2.14.0",
     "metaschema": "^0.0.7",
     "metatests": "^0.2.1"

test/array.every.js

@@ -40,9 +40,9 @@ metatests.test('every with error', test => {
   });
 });
 
-metatests.test('every with empty array', test => (
+metatests.test('every with empty array', test =>
   strictSameResult([], true, test, () => test.end())
-));
+);
 
 metatests.test(
   'every with one-element arrays',

test/array.filter.js

@@ -14,9 +14,9 @@ metatests.test('successful filter', test => {
     'do', 'ut', 'et', 'magna',
   ];
 
-  metasync.filter(arr, (str, callback) => process.nextTick(() => (
+  metasync.filter(arr, (str, callback) => process.nextTick(() =>
     callback(null, str.length < 6)
-  )), (err, res) => {
+  ), (err, res) => {
     test.error(err);
     test.same(res.join(), expectedArr.join());
     test.end();
@@ -27,9 +27,9 @@ metatests.test('filter with empty array', test => {
   const arr = [];
   const expectedArr = [];
 
-  metasync.filter(arr, (str, callback) => process.nextTick(() => (
+  metasync.filter(arr, (str, callback) => process.nextTick(() =>
     callback(null, str.length < 6)
-  )), (err, res) => {
+  ), (err, res) => {
     test.error(err);
     test.strictSame(res, expectedArr);
     test.end();

test/array.find.js

@@ -24,9 +24,9 @@ metatests.test('find with error', test => {
 metatests.test('find', test => {
   const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
   const expected = 15;
-  const predicate = (item, callback) => process.nextTick(() => (
+  const predicate = (item, callback) => process.nextTick(() =>
     callback(null, item % 3 === 0 && item % 5 === 0)
-  ));
+  );
 
   metasync.find(data, predicate, (err, result) => {
     test.error(err, 'must not return an error');
@@ -36,22 +36,26 @@ metatests.test('find', test => {
 });
 
 metatests.test('with empty array', test => {
-  metasync.find([], (el, callback) => (
-    process.nextTick(() => callback(null, true))
-  ), (err, result) => {
-    test.error(err);
-    test.strictSame(result, undefined);
-    test.end();
-  });
+  metasync.find(
+    [],
+    (el, callback) => process.nextTick(() => callback(null, true)),
+    (err, result) => {
+      test.error(err);
+      test.strictSame(result, undefined);
+      test.end();
+    }
+  );
 });
 
 metatests.test('with array without element which is searching', test => {
   const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
-  metasync.find(data, (el, callback) => (
-    process.nextTick(() => callback(null, el === 20))
-  ), (err, result) => {
-    test.error(err);
-    test.strictSame(result, undefined);
-    test.end();
-  });
+  metasync.find(
+    data,
+    (el, callback) => process.nextTick(() => callback(null, el === 20)),
+    (err, result) => {
+      test.error(err);
+      test.strictSame(result, undefined);
+      test.end();
+    }
+  );
 });

test/array.map.js

@@ -7,26 +7,30 @@ metatests.test('succesfull map', test => {
   const arr = [1, 2, 3];
   const expectedArr = [1, 4, 9];
 
-  metasync.map(arr, (x, callback) => (
-    process.nextTick(() => callback(null, x * x))
-  ), (err, res) => {
-    test.error(err);
-    test.strictSame(res, expectedArr);
-    test.end();
-  });
+  metasync.map(
+    arr,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
+      test.end();
+    }
+  );
 });
 
 metatests.test('map with empty array', test => {
   const arr = [];
   const expectedArr = [];
 
-  metasync.map(arr, (x, callback) => (
-    process.nextTick(() => callback(null, x * x))
-  ), (err, res) => {
-    test.error(err);
-    test.strictSame(res, expectedArr);
-    test.end();
-  });
+  metasync.map(
+    arr,
+    (x, callback) => process.nextTick(() => callback(null, x * x)),
+    (err, res) => {
+      test.error(err);
+      test.strictSame(res, expectedArr);
+      test.end();
+    }
+  );
 });
 
 metatests.test('map with error', test => {