add optionnable sorting capability

README.md

@@ -35,7 +35,8 @@ with help of [filer](https://github.com/filerjs/filer "Node-like file system for
 ```js
 const readify = require('readify');
 
-radify('/', (error, data) => {
+// basic
+readify('/', (error, data) => {
     console.log(data);
     // output
     {
@@ -45,12 +46,14 @@ radify('/', (error, data) => {
             size: '4.22kb',
             date: '20.02.2016',
             owner: 'coderaiser',
-            mode: 'rw- rw- r--'
+            mode: 'rw- rw- r--',
+            _raw: [object] // see bellow
         }]
     }
 });
 
-radify('/', 'raw', (error, data) => {
+// raw output
+readify('/', 'raw', (error, data) => {
     console.log(data);
     // output
     {
@@ -64,6 +67,19 @@ radify('/', 'raw', (error, data) => {
         }]
     }
 });
+
+// sort output
+// available sort option: name, size, owner, date
+// available order option: asc, desc
+readify('/', {sort: 'size', order: 'desc'}, (error, data) => {
+    console.log(data);
+});
+
+// all together
+readify('/', {sort: 'size', order: 'desc', type: 'raw'}, (error, data) => {
+    console.log(data);
+});
+
 ```
 
 `browser` example:

lib/readify.js

@@ -31,24 +31,77 @@ const nicki = !WIN && !BROWSER && require('nicki/legacy');
 const readdir = promisify(fs.readdir, fs);
 
 /* sorting on Win and node v0.8.0 */
-const sortFiles = sort((a, b) => {
-    return a.name > b.name ? 1 : -1;
+const sortFiles = currify((attr, order, array) => {
+    switch (order) {
+    case 'desc':
+        // nothing
+        break;
+    case 'asc':
+        // nothing
+        break;
+    default:
+        order = 'asc';
+    }
+    var cmp;
+    switch (attr) {
+    case 'size':
+        cmp = (a, b) => (+a - +b);
+        break;
+    case 'date':
+        cmp = (a, b) => (a > b ? 1 : -1);
+        break;
+    case 'owner':
+        cmp = (a, b) => (a > b ? 1 : -1);
+        break;
+    case 'name':
+        cmp = (a, b) => a.localeCompare(b.attr);
+        break;
+    default:
+        attr = 'name';
+        cmp = (a, b) => a.localeCompare(b.attr);
+    }
+    return sort((a, b) => {
+        var res;
+        if (typeof a.raw !== 'undefined' && typeof b.raw !== 'undefined') {
+            res = cmp(a.raw[attr], b.raw[attr]);
+        } else {
+            res = cmp(a[attr], b[attr]);
+        }
+        if (order === 'desc') {
+            res = -res;
+        }
+        return res;
+    }, array);
 });
 
 const good = (f) => (...a) => f(null, ...a);
 
 module.exports = readify;
 
-function readify(path, type, fn) {
+function readify(path, options, fn) {
     if (!fn) {
-        fn = type;
-        type = '';
+        fn = options;
+        options = '';
+    }
+    if (typeof options !== 'object') {
+        options = {
+            type: options,
+        };
+    }
+    if (typeof options.sort === 'undefined') {
+        options.sort = '';
+    }
+    if (typeof options.order === 'undefined') {
+        options.order = '';
+    }
+    if (typeof options.type === 'undefined') {
+        options.type = '';
     }
 
     check(path, fn);
 
     readdir(path)
-        .then(getAllStats(path, type))
+        .then(getAllStats(path, options))
         .then(good(fn))
         .catch(fn);
 }
@@ -68,20 +121,20 @@ function check(path, callback) {
  * @param path
  * @param names
  */
-function _getAllStats(path, type, names, callback) {
+function _getAllStats(path, options, names, callback) {
     const length = names.length;
     const dir = format.addSlashToEnd(path);
 
     if (!length)
-        return fillJSON(dir, [], type, callback);
+        return fillJSON(dir, [], options, callback);
 
     const funcs = names.map((name) => {
         return getStat(name, dir + name);
     });
 
     exec.parallel(funcs, (...args) => {
         const files = args.slice(1);
-        fillJSON(dir, files, type, callback);
+        fillJSON(dir, files, options, callback);
     });
 }
 
@@ -111,15 +164,16 @@ function _parseAllStats(type, array) {
 function parseStat(type, stat) {
     const isDir = stat.isDirectory();
     const size = isDir ? 'dir' : stat.size;
-
-    if (type === 'raw')
-        return {
+    const raw = {
             name: stat.name,
             size: size,
             date: stat.mtime,
             owner: stat.uid,
             mode: stat.mode
         };
+
+    if (type === 'raw')
+        return raw;
 
     /* Переводим права доступа в 8-ричную систему */
     const modeStr = Number(stat.mode).toString(8);
@@ -134,7 +188,8 @@ function parseStat(type, stat) {
         size: format.size(size),
         date: mtime,
         owner: owner,
-        mode: mode && format.permissions.symbolic(mode)
+        mode: mode && format.permissions.symbolic(mode),
+        raw: raw
     };
 }
 
@@ -143,16 +198,16 @@ function parseStat(type, stat) {
  *
  * @param params - { files, stats, path }
  */
-function fillJSON(path, stats, type, callback) {
-    const processFiles = squad(changeOrder, sortFiles, parseAllStats(type));
+function fillJSON(path, stats, options, callback) {
+    const processFiles = squad(changeOrder, sortFiles(options.sort, options.order), parseAllStats(options.type));
     const json = {
         path: '',
         files: processFiles(stats)
     };
 
     json.path = format.addSlashToEnd(path);
 
-    if (type === 'raw')
+    if (options.type === 'raw')
         return callback(null, json);
 
     changeUIDToName(json, (error, files) => {

test/dir/1.txt

@@ -0,0 +1 @@
+111

test/dir/2.txt

@@ -0,0 +1 @@
+2

test/dir/3.txt

@@ -0,0 +1 @@
+33

test/readify.js

@@ -62,7 +62,7 @@ test('result: should be sorted by name folders then files', (t) => {
     });
 });
 
-test('readify: result: no owner', (t) => {
+test('readify: result', (t) => {
     const update = () => {
         delete require.cache[require.resolve('..')];
         readify = require('..');
@@ -107,51 +107,12 @@ test('readify: result: no owner', (t) => {
     update();
 
     readify('.', (error, result) => {
-        delete result.files[0].owner;
-        t.deepEqual(result, expected, 'should get raw values');
-
-        fs.readdir = readdir;
-        fs.stat = stat;
-
-        update();
-
-        t.end();
-    });
-});
-
-test('readify: result: owner', (t) => {
-    const update = () => {
-        delete require.cache[require.resolve('..')];
-        readify = require('..');
-    };
-
-    const {readdir, stat} = fs;
-
-    const name = 'hello.txt';
-    const mode = 16893;
-    const size = 1024;
-    const mtime = new Date('2016-11-23T14:36:46.311Z');
-    const uid = 2;
-
-    fs.readdir = (dir, fn) => {
-        fn(null, [name]);
-    };
-
-    fs.stat = (name, fn) => {
-        fn(null, {
-            isDirectory: noop,
-            name,
-            mode,
-            size,
-            mtime,
-            uid
+        result.files = result.files.map(function(file) {
+            delete file.raw;
+            delete file.owner;
+            return file;
         });
-    };
-
-    update();
-
-    readify('.', (error, result) => {
-        t.ok(result.files[0].owner, 'should contain owner');
+        t.deepEqual(result, expected, 'should get raw values');
 
         fs.readdir = readdir;
         fs.stat = stat;
@@ -276,7 +237,7 @@ test('result: files should have fields name, size, date, owner, mode', (t) => {
             length      = files.length,
             check       = () =>
                 files.filter((file) =>
-                    Object.keys(file).join(':') === 'name:size:date:owner:mode'
+                    Object.keys(file).join(':') === 'name:size:date:owner:mode:raw'
                 ).length;
 
         t.notOk(error, 'no error');
@@ -356,14 +317,100 @@ test('readify stat: error', (t) => {
     const dir = path.resolve(__dirname, '..', 'dist');
     readify(dir, (error, data) => {
         t.notOk(error, 'no error when stat error');
-
+        data.files = data.files.map(function(file) {
+            delete file.raw;
+            return file;
+        });
         t.deepEqual(data.files, files, 'size, date, owner, mode should be empty');
 
         fs.stat = stat;
         t.end();
     });
 });
 
+test('readify sort: name asc', (t) => {
+    const files = [
+        '1.txt',
+        '2.txt',
+        '3.txt'
+    ];
+
+    readify('./test/dir', {sort: 'name'}, (error, data) => {
+        t.notOk(error, 'no error');
+        data.files = data.files.map(function(file) {
+            return file.name;
+        });
+        t.deepEqual(data.files, files, 'correct order');
+        t.end();
+    });
+});
+
+test('readify sort: name desc', (t) => {
+    const files = [
+        '3.txt',
+        '2.txt',
+        '1.txt'
+    ];
+
+    readify('./test/dir', {sort: 'name', order: 'desc'}, (error, data) => {
+        t.notOk(error, 'no error');
+        data.files = data.files.map(function(file) {
+            return file.name;
+        });
+        t.deepEqual(data.files, files, 'correct order');
+        t.end();
+    });
+});
+
+test('readify sort: size asc', (t) => {
+    const files = [
+        '2.txt',
+        '3.txt',
+        '1.txt'
+    ];
+
+    readify('./test/dir', {sort: 'size', order: 'asc'}, (error, data) => {
+        t.notOk(error, 'no error');
+        data.files = data.files.map(function(file) {
+            return file.name;
+        });
+        t.deepEqual(data.files, files, 'correct order');
+        t.end();
+    });
+});
+
+test('readify sort: size asc raw', (t) => {
+    const files = [
+        '2.txt',
+        '3.txt',
+        '1.txt'
+        ];
+
+    readify('./test/dir', {sort: 'size', type: 'raw'}, (error, data) => {
+        t.notOk(error, 'no error');
+        data.files = data.files.map(function(file) {
+            return file.name;
+        });
+        t.deepEqual(data.files, files, 'correct order');
+        t.end();
+    });
+});
+
+// no comment
+test('readify sort: owner', (t) => {
+    readify('./test/dir', {sort: 'owner'}, (error) => {
+        t.notOk(error, 'no error');
+        t.end();
+    });
+});
+
+test('readify sort: date', (t) => {
+    readify('./test/dir', {sort: 'date'}, (error) => {
+        t.notOk(error, 'no error');
+        t.end();
+    });
+});
+
 test('browser: filer', (t) => {
     const Filer = {
         FileSystem: sinon.stub()