feature(trammel) drop support of node < 10 (#1)

Author: coderaiser

.eslintrc.json

@@ -1,4 +1,7 @@
 {
+    "rules": {
+        "node/no-unsupported-features/node-builtins": "off"
+    },
     "extends": [
         "plugin:putout/recommended",
         "plugin:node/recommended"

.eslintrc.test

@@ -2,5 +2,3 @@
 test
 yarn-error.log
 
-madrun.js
-

.npmignore

@@ -1,8 +1,8 @@
 language: node_js
 node_js:
+    - 14
     - 12
     - 10
-    - 8
 
 script:
   - npm run lint

.travis.yml

@@ -16,25 +16,19 @@ If you want get realtime size updates use [dirsize](https://github.com/coderaise
 ## Example
 
 ```js
-const trammel = require('trammel');
+import trammel from 'trammel';
 
-trammel('.', (error, size) => {
-    console.log(error, size);
-    //undefined '58.47kb'
-});
+await trammel('.');
+// returns
+'58.47kb'
 
-trammel('.', {type: 'raw'}, (error, size) => {
-    console.log(error, size);
-    //undefined 59974
-});
-
-trammel('do not exist', {stopOnError: true}, (error, size) => {
-    if (error)
-        return console.error(error.message);
-    
-    console.log(size);
-});
+await trammel('.', {type: 'raw'});
+// returns
+59974
 
+await trammel('do not exist', {stopOnError: true});
+// returns
+Error
 ```
 
 ## License

README.md

@@ -1,19 +1,20 @@
 'use strict';
 
-const fs = require('fs');
+const {promisify} = require('util');
+const {lstat, readdir} = require('fs').promises;
 const path = require('path');
 const {EventEmitter} = require('events');
 
 const format = require('format-io');
+const tryToCatch = require('try-to-catch');
 
 /*  The lstat() function shall be equivalent to stat(),
     except when path refers to a symbolic link. In that case lstat()
     shall return information about the link, while stat() shall return
     information about the file the link references.
 */
-const stat = fs.lstat;
 
-module.exports = (dir, options, callback) => {
+module.exports = promisify((dir, options, callback) => {
     const emitter = new EventEmitter();
 
     let total = 0;
@@ -26,8 +27,6 @@ module.exports = (dir, options, callback) => {
         type = options.type;
     }
 
-    check(dir, callback);
-    
     emitter.on('file', (file, stat) => {
         total += stat.size;
     });
@@ -42,7 +41,7 @@ module.exports = (dir, options, callback) => {
     });
 
     processDir(dir, options, emitter);
-};
+});
 
 function processDir(dir, options, emitter) {
     const {stopOnError} = options;
@@ -60,13 +59,11 @@ function processDir(dir, options, emitter) {
         emitter.emit('end');
     };
 
-    const getDirInfo = (dir) => {
-        stat(dir, getStat.bind(null, dir));
-    };
-    
     getDirInfo(dir);
 
-    function getStat(dir, error, stat) {
+    async function getDirInfo(dir) {
+        const [error, stat] = await tryToCatch(lstat, dir);
+        
         --fileCounter;
 
         if (error && stopOnError) {
@@ -90,19 +87,19 @@ function processDir(dir, options, emitter) {
 
         execCallBack();
 
-        fs.readdir(dir, (error, files) => {
-            asyncRunning--;
-            
-            if (!error)
-                return onReaddir(dir, files);
-            
-            if (error && stopOnError) {
-                wasError = true;
-                emitter.emit('error', error);
-            }
-            
-            execCallBack();
-        });
+        const [readError, files] = await tryToCatch(readdir, dir);
+        
+        asyncRunning--;
+        
+        if (!readError)
+            return onReaddir(dir, files);
+        
+        if (readError && stopOnError) {
+            wasError = true;
+            emitter.emit('error', readError);
+        }
+        
+        execCallBack();
     }
 
     function onReaddir(dir, files) {
@@ -120,11 +117,3 @@ function processDir(dir, options, emitter) {
     }
 }
 
-function check(dir, callback) {
-    if (!dir)
-        throw Error('dir could not be empty!');
-    
-    if (!callback)
-        throw Error('callback could not be empty!');
-
-}

lib/trammel.js

@@ -21,25 +21,25 @@
     "watcher": "madrun watcher"
   },
   "dependencies": {
-    "format-io": "^2.0.0"
+    "events.once": "^2.0.2",
+    "format-io": "^2.0.0",
+    "try-to-catch": "^3.0.0"
   },
   "devDependencies": {
     "coveralls": "^3.0.1",
     "eslint": "^6.4.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-putout": "^3.7.1",
     "madrun": "^5.5.0",
+    "mock-require": "^3.0.3",
     "nodemon": "^1.17.5",
     "nyc": "^15.0.1",
     "putout": "^7.23.0",
-    "supertape": "^1.2.3",
-    "tape": "^4.9.1",
-    "try-catch": "^3.0.0",
-    "try-to-catch": "^3.0.0"
+    "supertape": "^1.2.3"
   },
   "license": "MIT",
   "engines": {
-    "node": ">=8"
+    "node": ">=10"
   },
   "main": "lib/trammel.js",
   "publishConfig": {

package.json

@@ -5,32 +5,31 @@ const fs = require('fs');
 
 const test = require('supertape');
 const tryToCatch = require('try-to-catch');
-const tryCatch = require('try-catch');
-const {promisify} = require('util');
+const {reRequire} = require('mock-require');
+
 const trammel = require('..');
-const trammel_ = promisify(trammel);
 
 const fixturePath = path.join(__dirname, 'fixture');
 
 test('trammel: size of a file', async (t) => {
     const expected = '12b';
-    const [, size] = await tryToCatch(trammel_, `${fixturePath}/file.txt`);
+    const [, size] = await tryToCatch(trammel, `${fixturePath}/file.txt`);
 
     t.equal(expected, size, 'should equal');
     t.end();
 });
 
 test('trammel: size of a directory', async (t) => {
     const expected = '12b';
-    const [, size] = await tryToCatch(trammel_, `${fixturePath}/dir`);
+    const [, size] = await tryToCatch(trammel, `${fixturePath}/dir`);
 
     t.equal(expected, size, 'should equal');
     t.end();
 });
 
 test('trammel: size of a directory: empty dir: raw', async (t) => {
     const expected = 0;
-    const [, size] = await tryToCatch(trammel_, `${fixturePath}/empty-dir`, {
+    const [, size] = await tryToCatch(trammel, `${fixturePath}/empty-dir`, {
         type: 'raw',
     });
 
@@ -40,67 +39,78 @@ test('trammel: size of a directory: empty dir: raw', async (t) => {
 
 test('trammel: stopOnError: false', async (t) => {
     const expected = '0b';
-    const [, size] = await tryToCatch(trammel_, 'abcef');
+    const [, size] = await tryToCatch(trammel, 'abcef');
 
     t.equal(size, expected, 'should equal');
     t.end();
 });
 
 test('trammel: error', async (t) => {
-    const [, size] = await tryToCatch(trammel_, 'abcd');
+    const [, size] = await tryToCatch(trammel, 'abcd');
 
     t.equal(size, '0b', 'should equal');
     t.end();
 });
 
 test('trammel: stopOnError: true', async (t) => {
-    const [e] = await tryToCatch(trammel_, 'abcd', {stopOnError: true});
+    const [e] = await tryToCatch(trammel, 'abcd', {stopOnError: true});
 
     t.equal(e.code, 'ENOENT', 'should equal');
     t.end();
 });
 
 test('trammel: stopOnError: true: can not readdir', async (t) => {
     const error = Error('hello');
-    const {readdir} = fs;
+    const {readdir} = fs.promises;
+    
+    fs.promises.readdir = async () => {
+        throw error;
+    };
 
-    fs.readdir = (dir, fn) => fn(error);
+    const trammel = reRequire('..');
 
-    const [e] = await tryToCatch(trammel_, fixturePath, {
+    const [e] = await tryToCatch(trammel, fixturePath, {
         stopOnError: true,
     });
 
-    fs.readdir = readdir;
+    fs.promises.readdir = readdir;
 
     t.equal(e.message, 'hello', 'should equal');
     t.end();
 });
 
-test('trammel: can not readdir', async (t) => {
-    const expected = '0b';
-    const {readdir} = fs;
+test('trammel: readdir: empty', async (t) => {
+    const {readdir} = fs.promises;
 
-    fs.readdir = (dir, fn) => fn(Error('hi'));
+    fs.promises.readdir = async () => [];
 
-    const [, size] = await tryToCatch(trammel_, fixturePath);
+    const trammel = reRequire('..');
 
-    fs.readdir = readdir;
+    const size = await trammel(fixturePath, {
+        type: 'raw',
+    });
 
-    t.equal(size, expected, 'should equal');
-    t.end();
-});
-
-test('trammel: arguments: no', async (t) => {
-    const [e] = tryCatch(trammel);
+    fs.promises.readdir = readdir;
 
-    t.equal(e.message, 'dir could not be empty!', 'should equal');
+    t.equal(size, 0, 'should equal');
     t.end();
 });
 
-test('trammel: arguments: no callback', async (t) => {
-    const [e] = tryCatch(trammel, '/');
+test('trammel: can not readdir', async (t) => {
+    const expected = '0b';
+    const {readdir} = fs.promises;
+    
+    fs.promises.readdir = () => {
+        throw Error('hi');
+    };
 
-    t.equal(e.message, 'callback could not be empty!', 'should equal');
+    const trammel = reRequire('..');
+    
+    const [, size] = await tryToCatch(trammel, fixturePath);
+    
+    fs.promises.readdir = readdir;
+    
+    t.equal(size, expected, 'should equal');
     t.end();
 });