Initial commit — jibo-cli v3.0.7 with bundled node_modules

node_modules/wrench/tests/copydirsync_unix.js

@@ -0,0 +1,242 @@
+var testCase = require('nodeunit').testCase;
+var fs = require('fs');
+var wrench = require('../lib/wrench');
+var path = require('path');
+
+function checkResultHidden(test, files) {
+    var check = [
+        '.hidden',
+        '.hidden.txt',
+        'bar.txt',
+        'foo',
+        path.join('.hidden', 'dolor.md'),
+        path.join('foo', 'bar'),
+        path.join('foo', 'dolor.md'),
+        path.join('foo', 'lorem.txt'),
+        path.join('foo', 'bar', 'ipsum.js')
+    ];
+
+    test.deepEqual(files, check);
+}
+
+function checkResultShown(test, files) {
+    var check = [
+        'bar.txt',
+        'foo',
+        path.join('foo', 'bar'),
+        path.join('foo', 'dolor.md'),
+        path.join('foo', 'lorem.txt'),
+        path.join('foo', 'bar', 'ipsum.js')
+    ];
+
+    test.deepEqual(files, check);
+}
+
+function checkResultInflate(test, files) {
+    var check = [
+        '.hidden',
+        'bar.txt',
+        'test',
+        path.join('.hidden', 'dolor.md')
+    ];
+
+    test.deepEqual(files, check);
+
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/.hidden')).isSymbolicLink(), false);
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/bar.txt')).isSymbolicLink(), false);
+}
+
+function checkResultInflateAbsolute(test, files) {
+    var check = [
+        '.hidden',
+        'absolute-bar.txt',
+        'bar.txt',
+        'test',
+        path.join('.hidden', 'dolor.md')
+    ];
+
+    test.deepEqual(files, check);
+
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/.hidden')).isSymbolicLink(), false);
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/bar.txt')).isSymbolicLink(), false);
+}
+
+function checkResultDontInflate(test, files) {
+    var check = [
+        '.hidden',
+        'bar.txt',
+        'test',
+        path.join('.hidden', 'dolor.md')
+    ];
+
+    test.deepEqual(files, check);
+
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/.hidden')).isSymbolicLink(), true);
+    test.deepEqual(fs.lstatSync(path.join(__dirname, 'testdir/bar.txt')).isSymbolicLink(), true);
+}
+
+function checkResultPreserveFiles(test, files) {
+    checkResultHidden(test, files);
+    var contents = fs.readFileSync(path.join(__dirname, path.join('testdir2', '.hidden.txt')), "utf8");
+    test.deepEqual(contents, 'hidden file');
+    contents = fs.readFileSync(path.join(__dirname, path.join('testdir2', 'bar.txt')), "utf8");
+    test.deepEqual(contents, 'shown file');
+}
+
+function checkResultOverwriteFiles(test, files) {
+    checkResultHidden(test, files);
+    var contents = fs.readFileSync(path.join(__dirname, path.join('testdir2', '.hidden.txt')), "utf8");
+    test.deepEqual(contents, 'just some text for .hidden.txt');
+    contents = fs.readFileSync(path.join(__dirname, path.join('testdir2', 'bar.txt')), "utf8");
+    test.deepEqual(contents, 'just some text for bar.txt');
+}
+
+module.exports = testCase({
+    test_copyDirSyncRecursiveWithoutOptions: function(test) {
+        var dir = path.join(__dirname, 'shown');
+        var testdir = path.join(__dirname, 'testdir');
+
+        wrench.copyDirSyncRecursive(dir, testdir);
+
+        wrench.rmdirSyncRecursive(testdir);
+        test.done();
+    },
+    test_copyDirSyncRecursiveHidden: function(test) {
+        var dir = path.join(__dirname, 'shown');
+        var testdir = path.join(__dirname, 'testdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        wrench.copyDirSyncRecursive(dir, testdir, { excludeHiddenUnix: false });
+
+        var files = wrench.readdirSyncRecursive(testdir);
+
+        checkResultHidden(test, files);
+
+        wrench.rmdirSyncRecursive(testdir);
+
+        test.done();
+    },
+    test_copyDirSyncRecursiveShown: function(test) {
+        var dir = path.join(__dirname, 'shown');
+        var testdir = path.join(__dirname, 'testdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        wrench.copyDirSyncRecursive(dir, testdir, { excludeHiddenUnix: true });
+
+        var files = wrench.readdirSyncRecursive(testdir);
+
+        checkResultShown(test, files);
+
+        wrench.rmdirSyncRecursive(testdir);
+
+        test.done();
+    },
+    test_copyDirSyncRecursiveInflate: function(test) {
+        var dir = path.join(__dirname, 'withsymlinks');
+        var testdir = path.join(__dirname, 'testdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        wrench.copyDirSyncRecursive(dir, testdir, { excludeHiddenUnix: false, inflateSymlinks: true });
+
+        var files = wrench.readdirSyncRecursive(testdir);
+
+        checkResultInflate(test, files);
+
+        wrench.rmdirSyncRecursive(testdir);
+
+        test.done();
+    },
+    test_copyDirSyncRecursiveInflateAbsoluteSymlinks: function(test) {
+        var dir = path.join(__dirname, 'withsymlinks');
+        var testdir = path.join(__dirname, 'testdir');
+
+        fs.symlinkSync(
+            path.resolve(__dirname, 'shown/bar.txt'),
+            path.join(dir, 'absolute-bar.txt')
+        );
+
+        wrench.mkdirSyncRecursive(testdir, 0777);
+        wrench.copyDirSyncRecursive(dir, testdir, { forceDelete: true, excludeHiddenUnix: false, inflateSymlinks: true });
+
+        var files = wrench.readdirSyncRecursive(testdir);
+
+        checkResultInflateAbsolute(test, files);
+
+        wrench.rmdirSyncRecursive(testdir);
+        fs.unlinkSync(path.join(dir, 'absolute-bar.txt'));
+
+        test.done();
+    },
+    test_copyDirSyncRecursiveDontInflate: function(test) {
+        var dir = path.join(__dirname, 'withsymlinks');
+        var testdir = path.join(__dirname, 'testdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        wrench.copyDirSyncRecursive(dir, testdir, { excludeHiddenUnix: false, inflateSymlinks: false });
+
+        var files = wrench.readdirSyncRecursive(testdir);
+
+        checkResultDontInflate(test, files);
+
+        wrench.rmdirSyncRecursive(testdir);
+
+        test.done();
+    },
+    test_copyDirSyncRecursivePreserveFiles: function(test) {
+        var dir = path.join(__dirname, 'shown'),
+            testdir1 = path.join(__dirname, 'testdir1'),
+            testdir2 = path.join(__dirname, 'testdir2');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        // wrench.mkdirSyncRecursive(testdir1, 0777);
+        wrench.copyDirSyncRecursive(dir, testdir1, { excludeHiddenUnix: false });
+        wrench.copyDirSyncRecursive(dir, testdir2, { excludeHiddenUnix: false });
+
+        fs.writeFileSync(path.join(testdir1, ".hidden.txt"), 'just some text for .hidden.txt');
+        fs.writeFileSync(path.join(testdir1, "bar.txt"), 'just some text for bar.txt');
+
+        wrench.copyDirSyncRecursive(testdir1, testdir2, { excludeHiddenUnix: false, preserveFiles: true });
+
+        var files = wrench.readdirSyncRecursive(testdir2);
+
+        checkResultPreserveFiles(test, files);
+
+        wrench.rmdirSyncRecursive(testdir1);
+        wrench.rmdirSyncRecursive(testdir2);
+
+        test.done();
+    },
+    test_copyDirSyncRecursiveOverwriteFiles: function(test) {
+        var dir = path.join(__dirname, 'shown'),
+            testdir1 = path.join(__dirname, 'testdir1'),
+            testdir2 = path.join(__dirname, 'testdir2');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        // wrench.mkdirSyncRecursive(testdir1, 0777);
+        wrench.copyDirSyncRecursive(dir, testdir1, { excludeHiddenUnix: false });
+        wrench.copyDirSyncRecursive(dir, testdir2, { excludeHiddenUnix: false });
+
+        fs.writeFileSync(path.join(testdir1, ".hidden.txt"), 'just some text for .hidden.txt');
+        fs.writeFileSync(path.join(testdir1, "bar.txt"), 'just some text for bar.txt');
+
+        wrench.copyDirSyncRecursive(testdir1, testdir2, { forceDelete: true, excludeHiddenUnix: false, preserveFiles: false });
+
+        var files = wrench.readdirSyncRecursive(testdir2);
+
+        checkResultOverwriteFiles(test, files);
+
+        wrench.rmdirSyncRecursive(testdir1);
+        wrench.rmdirSyncRecursive(testdir2);
+
+        test.done();
+    }
+
+});
+
+// vim: et ts=4 sw=4

node_modules/wrench/tests/mkdir.js

@@ -0,0 +1,26 @@
+var testCase = require('nodeunit').testCase;
+var fs = require('fs');
+var wrench = require('../lib/wrench');
+var path = require('path');
+
+module.exports = testCase({
+    test_mkdirSyncRecursive: function(test) {
+        var dir = __dirname + '/_tmp/foo/bar';
+
+        test.equals(fs.existsSync(dir), false, 'Dir shouldn\'t exist - clean it up manually?');
+
+        wrench.mkdirSyncRecursive(dir, 0777);
+
+        test.equals(fs.existsSync(dir), true, 'Dir should exist now');
+
+        // clean up
+        while (dir != __dirname) {
+            fs.rmdirSync(dir);
+            dir = path.dirname(dir);
+        }
+
+        test.done();
+    },
+});
+
+// vim: et ts=4 sw=4

node_modules/wrench/tests/readdir.js

@@ -0,0 +1,61 @@
+var testCase = require('nodeunit').testCase;
+var fs = require('fs');
+var wrench = require('../lib/wrench');
+var path = require('path');
+
+
+function checkResult(test, files) {
+    var check = [
+            'bar.txt',
+            'foo',
+            path.join('foo', 'bar'),
+            path.join('foo', 'dolor.md'),
+            path.join('foo', 'lorem.txt'),
+            path.join('foo', 'bar', 'ipsum.js')
+        ];
+
+    test.deepEqual(files, check);
+
+    test.done();
+}
+
+module.exports = testCase({
+    test_readdirSyncRecursive: function(test) {
+        var dir = path.join(__dirname, 'readdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        var files = wrench.readdirSyncRecursive(dir);
+
+        checkResult(test, files);
+    },
+
+    test_readdirRecursive: function(test) {
+        var dir = path.join(__dirname, 'readdir');
+
+        test.ok(fs.existsSync(dir), 'Folders should exist');
+
+        var allFiles = [];
+
+        wrench.readdirRecursive(dir, function(e, files) {
+            if (e) throw e;
+
+            if (files) {
+                allFiles = allFiles.concat(files);
+            } else {
+                checkResult(test, allFiles);
+            }
+        });
+    },
+
+    test_readdirRecursiveWithNonExistentDirectory: function(test) {
+        wrench.readdirRecursive('', function (e, files) {
+            test.ok(e);
+            test.equal(e.code, 'ENOENT');
+            test.equal(files, null);
+            test.done();
+        });
+    }
+});
+
+// vim: et ts=4 sw=4

node_modules/wrench/tests/rmdirSyncRecursive.js

@@ -0,0 +1,74 @@
+var testCase = require('nodeunit').testCase;
+var fs = require('fs');
+var wrench = require('../lib/wrench');
+var path = require('path');
+
+module.exports = testCase({
+    test_rmdirSyncRecursive: function(test) {
+        var dir = __dirname + '/_tmp2/foo/bar';
+
+        wrench.mkdirSyncRecursive(dir, '777');
+
+        var f1Path = path.join(dir, 'test1.txt');
+        var f2Path = path.join(path.dirname(dir), 'test2.txt');
+        var f3Path = path.join(path.dirname(path.dirname(dir)), 'test3.txt');
+
+        fs.writeFileSync(f1Path, 'foo bar baz');
+        fs.writeFileSync(f2Path, 'foo bar baz');
+        fs.writeFileSync(f3Path, 'foo bar baz');
+
+        fs.chmodSync(f1Path, '444');
+        fs.chmodSync(f2Path, '444');
+        fs.chmodSync(f3Path, '444');
+
+        test.equals(fs.existsSync(dir), true, 'Dir should exist - mkdirSyncRecursive not working?');
+        test.equals(fs.existsSync(f1Path), true, 'File should exist');
+        test.equals(fs.existsSync(f2Path), true, 'File should exist');
+        test.equals(fs.existsSync(f3Path), true, 'File should exist');
+
+        wrench.rmdirSyncRecursive(dir);
+
+        test.equals(fs.existsSync(dir), false, 'Dir should not exist now...');
+        test.equals(fs.existsSync(f1Path), false, 'File should not exist');
+        test.equals(fs.existsSync(f2Path), true, 'File should exist');
+        test.equals(fs.existsSync(f3Path), true, 'File should exist');
+
+        wrench.rmdirSyncRecursive(path.dirname(path.dirname(dir)));
+
+        test.done();
+    },
+
+    test_rmdirSyncRecursiveFromRoot: function(test) {
+        var dir = __dirname + '/_tmp3/foo/bar';
+
+        wrench.mkdirSyncRecursive(dir, '777');
+
+        var f1Path = path.join(dir, 'test1.txt');
+        var f2Path = path.join(path.dirname(dir), 'test2.txt');
+        var f3Path = path.join(path.dirname(path.dirname(dir)), 'test3.txt');
+
+        fs.writeFileSync(f1Path, 'foo bar baz');
+        fs.writeFileSync(f2Path, 'foo bar baz');
+        fs.writeFileSync(f3Path, 'foo bar baz');
+
+        fs.chmodSync(f1Path, '444');
+        fs.chmodSync(f2Path, '444');
+        fs.chmodSync(f3Path, '444');
+
+        test.equals(fs.existsSync(dir), true, 'Dir should exist - mkdirSyncRecursive not working?');
+        test.equals(fs.existsSync(f1Path), true, 'File should exist');
+        test.equals(fs.existsSync(f2Path), true, 'File should exist');
+        test.equals(fs.existsSync(f3Path), true, 'File should exist');
+
+        wrench.rmdirSyncRecursive(path.dirname(path.dirname(dir)));
+
+        test.equals(fs.existsSync(dir), false, 'Dir should not exist now...');
+        test.equals(fs.existsSync(f1Path), false, 'File should not exist');
+        test.equals(fs.existsSync(f2Path), false, 'File should not exist');
+        test.equals(fs.existsSync(f3Path), false, 'File should not exist');
+
+        test.done();
+    }
+});
+
+// vim: et ts=4 sw=4

node_modules/wrench/tests/runner.js

@@ -0,0 +1,9 @@
+// `nodeunit tests/runner`
+// will run all the tests
+
+module.exports = {
+    group_mkdir: require('./mkdir'),
+    group_readdir: require('./readdir'),
+    group_copydir: require('./copydirsync_unix'),
+    group_rmdir: require('./rmdirSyncRecursive')
+};

node_modules/wrench/tests/shown/.hidden.txt

@@ -0,0 +1 @@
+hidden file

node_modules/wrench/tests/shown/bar.txt

@@ -0,0 +1 @@
+shown file

node_modules/wrench/tests/withsymlinks/test

@@ -0,0 +1 @@
+aaa bbb ccc ddd