refactor(Cypress): add nodemodules

node_modules/watchify/test/api.js

@@ -0,0 +1,44 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var file = path.join(tmpdir, 'main.js');
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(file, 'console.log(555)');
+
+test('api', function (t) {
+    t.plan(5);
+    var w = watchify(browserify(file, watchify.args));
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), '333\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), '555\n');
+        setTimeout(function () {
+            fs.writeFile(file, 'console.log(333)', function (err) {
+                t.ifError(err);
+            });
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/api_brfs.js

@@ -0,0 +1,53 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    lines: path.join(tmpdir, 'lines.txt')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, [
+    'var fs = require("fs");',
+    'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+    'console.log(src.toUpperCase());'
+].join('\n'));
+fs.writeFileSync(files.lines, 'beep\nboop');
+
+test('api with brfs', function (t) {
+    t.plan(5);
+    var w = watchify(browserify(files.main, watchify.args));
+    w.transform('brfs');
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), 'ROBO-BOOGIE\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), 'BEEP\nBOOP\n');
+        setTimeout(function () {
+            fs.writeFile(files.lines, 'rObO-bOOgie', function (err) {
+                t.ifError(err);
+            });
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/api_ignore_watch.js

@@ -0,0 +1,60 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch', function (t) {
+    t.plan(4);
+    var w = watchify(browserify(files.main, watchify.args), {
+        ignoreWatch: '**/be*.js'
+    });
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), 'beep BOOP ROBOT\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), 'beep boop robot\n');
+        setTimeout(function () {
+            fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+            fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+            fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/api_ignore_watch_default.js

@@ -0,0 +1,60 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch default', function (t) {
+    t.plan(4);
+    var w = watchify(browserify(files.main, watchify.args), {
+        ignoreWatch: true
+    });
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), 'BEEP BOOP robot\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), 'beep boop robot\n');
+        setTimeout(function () {
+            fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+            fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+            fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/api_ignore_watch_multiple.js

@@ -0,0 +1,60 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch multiple paths', function (t) {
+    t.plan(4);
+    var w = watchify(browserify(files.main, watchify.args), {
+        ignoreWatch: ['**/be*.js', '**/robot/*.js']
+    });
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), 'beep BOOP robot\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), 'beep boop robot\n');
+        setTimeout(function () {
+            fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+            fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+            fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/api_implicit_cache.js

@@ -0,0 +1,44 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var file = path.join(tmpdir, 'main.js');
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(file, 'console.log(555)');
+
+test('api implicit cache', function (t) {
+    t.plan(5);
+    var w = watchify(browserify(file));
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), '333\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), '555\n');
+        setTimeout(function () {
+            fs.writeFile(file, 'console.log(333)', function (err) {
+                t.ifError(err);
+            });
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/bin.js

@@ -0,0 +1,52 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, 'console.log(555)');
+
+test('bin', function (t) {
+    t.plan(5);
+    var ps = spawn(cmd, [ files.main, '-o', files.bundle, '-v' ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '555\n');
+                fs.writeFile(files.main, 'console.log(333)', t.ifError);
+            })
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '333\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_brfs.js

@@ -0,0 +1,62 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    lines: path.join(tmpdir, 'lines.txt'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, [
+    'var fs = require("fs");',
+    'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+    'console.log(src.toUpperCase());'
+].join('\n'));
+fs.writeFileSync(files.lines, 'beep\nboop');
+
+test('bin brfs', function (t) {
+    t.plan(5);
+    var ps = spawn(cmd, [
+        files.main,
+        '-t', require.resolve('brfs'), '-v',
+        '-o', files.bundle
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'BEEP\nBOOP\n');
+                fs.writeFile(files.lines, 'robo-bOOgie', t.ifError);
+            })
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'ROBO-BOOGIE\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_ignore_watch.js

@@ -0,0 +1,71 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch', function (t) {
+    t.plan(4);
+    var ps = spawn(cmd, [
+        files.main,
+        '--ignore-watch', '**/be*.js',
+        '-o', files.bundle,
+        '-v'
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'beep boop robot\n');
+                fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+                fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+                fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+            });
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'beep BOOP ROBOT\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_ignore_watch_default.js

@@ -0,0 +1,71 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch', function (t) {
+    t.plan(4);
+    var ps = spawn(cmd, [
+        files.main,
+        '--ignore-watch',
+        '-o', files.bundle,
+        '-v'
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'beep boop robot\n');
+                fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+                fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+                fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+            });
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'BEEP BOOP robot\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_ignore_watch_multiple.js

@@ -0,0 +1,72 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    robot: path.join(tmpdir, 'node_modules', 'robot', 'index.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.dirname(files.robot));
+fs.writeFileSync(files.main, [
+    'var beep = require("./beep");',
+    'var boop = require("./boop");',
+    'var robot = require("robot");',
+    'console.log(beep + " " + boop + " " + robot);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = "beep";');
+fs.writeFileSync(files.boop, 'module.exports = "boop";');
+fs.writeFileSync(files.robot, 'module.exports = "robot";');
+
+test('api ignore watch multiple paths', function (t) {
+    t.plan(4);
+    var ps = spawn(cmd, [
+        files.main,
+        '--ignore-watch', '**/be*.js',
+        '--ignore-watch', '**/robot/*.js',
+        '-o', files.bundle,
+        '-v'
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'beep boop robot\n');
+                fs.writeFileSync(files.beep, 'module.exports = "BEEP";');
+                fs.writeFileSync(files.boop, 'module.exports = "BOOP";');
+                fs.writeFileSync(files.robot, 'module.exports = "ROBOT";');
+            });
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, 'beep BOOP robot\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_pipe.js

@@ -0,0 +1,56 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, 'console.log(num * 2)');
+
+test('bin with pipe', function (t) {
+    t.plan(5);
+    var ps = spawn(cmd, [
+        files.main,
+        '-o', 'uglifyjs - --enclose 11:num > ' + files.bundle,
+        '-v'
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '22\n');
+                fs.writeFile(files.main, 'console.log(num * 3)', t.ifError);
+            });
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '33\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/bin_plugins_pipelining_multiple_errors.js

@@ -0,0 +1,56 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    plugin: path.join(tmpdir, 'plugin.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.plugin, [
+    'module.exports = function(b, opts) {',
+    '    b.on("file", function (file, id) {',
+    '        b.pipeline.emit("error", "bad boop");',
+    '        b.pipeline.emit("error", "bad boop");',
+    '    });',
+    '};',
+].join('\n'));
+fs.writeFileSync(files.main, 'boop\nbeep');
+
+test('bin plugins pipelining multiple errors', function (t) {
+    t.plan(4);
+    var ps = spawn(cmd, [
+        files.main,
+        '-p', files.plugin, '-v',
+        '-o', files.bundle
+    ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            t.equal(line, 'bad boop');
+        }
+        if (lineNum === 2) {
+            t.equal(line, 'bad boop');
+            setTimeout(function() {
+              fs.writeFileSync(files.main, 'beep\nboop');
+            }, 1000);
+        }
+        if (lineNum === 3) {
+            t.equal(line, 'bad boop');
+        }
+        if (lineNum === 4) {
+            t.equal(line, 'bad boop');
+            ps.kill();
+        }
+    });
+});

node_modules/watchify/test/bin_standalone.js

@@ -0,0 +1,52 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, 'console.log(555)');
+
+test('bin with standalone', function (t) {
+    t.plan(5);
+    var ps = spawn(cmd, [ files.main, '-o', files.bundle, '-v', '-s', 'XXX' ]);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        lineNum ++;
+        if (lineNum === 1) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '555\n');
+                fs.writeFile(files.main, 'console.log(333)', t.ifError);
+            })
+        }
+        else if (lineNum === 2) {
+            run(files.bundle, function (err, output) {
+                t.ifError(err);
+                t.equal(output, '333\n');
+                ps.kill();
+            });
+        }
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/errors.js

@@ -0,0 +1,56 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var file = path.join(tmpdir, 'main.js');
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(file, 'console.log(555)');
+
+test('errors', function (t) {
+    t.plan(5);
+    var w = watchify(browserify(file, watchify.args));
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), '555\n');
+        breakTheBuild();
+    });
+    function breakTheBuild() {
+        setTimeout(function() {
+            fs.writeFileSync(file, 'console.log(');
+        }, 1000);
+        w.once('update', function () {
+            w.bundle(function (err, src) {
+                t.ok(err instanceof Error, 'should be error');
+                fixTheBuild();
+            });
+        });
+    }
+    function fixTheBuild() {
+        setTimeout(function() {
+            fs.writeFileSync(file, 'console.log(333)');
+        }, 1000);
+        w.once('update', function () {
+            w.bundle(function (err, src) {
+                t.ifError(err);
+                t.equal(run(src), '333\n');
+                w.close();
+            });
+        });
+    }
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/errors_transform.js

@@ -0,0 +1,83 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var through = require('through2');
+
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var main = path.join(tmpdir, 'main.js');
+var file = path.join(tmpdir, 'dep.jsnum');
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(main, 'require("./dep.jsnum")');
+fs.writeFileSync(file, 'console.log(555)');
+
+function someTransform(file) {
+    if (!/\.jsnum$/.test(file)) {
+        return through();
+    }
+    function write (chunk, enc, next) {
+        if (/\d/.test(chunk)) {
+            this.push(chunk);
+        } else {
+            this.emit('error', new Error('No number in this chunk'));
+        }
+        next();
+    }
+    return through(write);
+}
+
+test('errors in transform', function (t) {
+    t.plan(6);
+    var b = browserify(main, watchify.args);
+    b.transform(someTransform);
+    var w = watchify(b);
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), '555\n');
+        breakTheBuild();
+    });
+    function breakTheBuild() {
+        setTimeout(function() {
+            fs.writeFileSync(file, 'console.log()');
+        }, 1000);
+        w.once('update', function () {
+            w.bundle(function (err, src) {
+                t.ok(err instanceof Error, 'should be error');
+                t.ok(/^No number in this chunk/.test(err.message));
+                fixTheBuild();
+            });
+        });
+    }
+    function fixTheBuild() {
+        setTimeout(function() {
+            fs.writeFileSync(file, 'console.log(333)');
+        }, 1000);
+        var safety = setTimeout(function() {
+            t.fail("gave up waiting");
+            w.close();
+            t.end();
+        }, 5000);
+        w.once('update', function () {
+            clearTimeout(safety);
+            w.bundle(function (err, src) {
+                t.ifError(err);
+                t.equal(run(src), '333\n');
+                w.close();
+            });
+        });
+    }
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/expose.js

@@ -0,0 +1,72 @@
+var test = require('tape');
+var watchify = require('../');
+var browserify = require('browserify');
+var vm = require('vm');
+
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+
+var os = require('os');
+var tmpbase = fs.realpathSync((os.tmpdir || os.tmpDir)());
+var tmpdir = path.join(tmpbase, 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    beep: path.join(tmpdir, 'beep.js'),
+    boop: path.join(tmpdir, 'boop.js'),
+    abc: path.join(tmpdir, 'lib', 'abc.js'),
+    xyz: path.join(tmpdir, 'lib', 'xyz.js')
+};
+
+mkdirp.sync(tmpdir);
+mkdirp.sync(path.join(tmpdir, 'lib'));
+
+fs.writeFileSync(files.main, [
+    'var abc = require("abc");',
+    'var xyz = require("xyz");',
+    'var beep = require("./beep");',
+    'console.log(abc + " " + xyz + " " + beep);'
+].join('\n'));
+fs.writeFileSync(files.beep, 'module.exports = require("./boop");');
+fs.writeFileSync(files.boop, 'module.exports = require("xyz");');
+fs.writeFileSync(files.abc, 'module.exports = "abc";');
+fs.writeFileSync(files.xyz, 'module.exports = "xyz";');
+
+test('properly caches exposed files', function (t) {
+    t.plan(4);
+    var cache = {};
+    var w = watchify(browserify({
+        entries: [files.main],
+        basedir: tmpdir,
+        cache: cache,
+        packageCache: {}
+    }));
+
+    w.require('./lib/abc', {expose: 'abc'});
+    w.require('./lib/xyz', {expose: 'xyz'});
+    w.on('update', function () {
+        w.bundle(function (err, src) {
+            t.ifError(err);
+            t.equal(run(src), 'ABC XYZ XYZ\n');
+            w.close();
+        });
+    });
+    w.bundle(function (err, src) {
+        t.ifError(err);
+        t.equal(run(src), 'abc xyz xyz\n');
+        setTimeout(function () {
+            // If we're incorrectly caching exposed files,
+            // then "files.abc" would be re-read from disk.
+            cache[files.abc].source = 'module.exports = "ABC";';
+            fs.writeFileSync(files.xyz, 'module.exports = "XYZ";');
+        }, 1000);
+    });
+});
+
+function run (src) {
+    var output = '';
+    function log (msg) { output += msg + '\n' }
+    vm.runInNewContext(src, { console: { log: log } });
+    return output;
+}

node_modules/watchify/test/many.js

@@ -0,0 +1,101 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    robot: path.join(tmpdir, 'robot.js'),
+    lines: path.join(tmpdir, 'lines.txt'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+var edits = [
+    { file: 'lines', source: 'robo-boogie' },
+    { file: 'lines', source: 'dinosaurus rex' },
+    {
+        file: 'robot',
+        source: 'module.exports = function (n) { return n * 111 }',
+        next: true
+    },
+    { file: 'main', source: [
+        'var fs = require("fs");',
+        'var robot = require("./robot.js");',
+        'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+        'console.log(src.toUpperCase() + " " + robot(src.length));'
+    ].join('\n') },
+    { file: 'lines', source: 't-rex' },
+    {
+        file: 'robot',
+        source: 'module.exports = function (n) { return n * 100 }',
+    }
+];
+
+var expected = [
+    'BEEP\nBOOP\n',
+    'ROBO-BOOGIE\n',
+    'DINOSAURUS REX\n',
+    'DINOSAURUS REX 1554\n',
+    'T-REX 555\n',
+    'T-REX 500\n'
+];
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, [
+    'var fs = require("fs");',
+    'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+    'console.log(src.toUpperCase());'
+].join('\n'));
+fs.writeFileSync(files.lines, 'beep\nboop');
+
+test('many edits', function (t) {
+    t.plan(expected.length * 2 + edits.length);
+    var ps = spawn(cmd, [
+        files.main,
+        '-t', require.resolve('brfs'), '-v',
+        '-o', files.bundle
+    ]);
+    ps.stdout.pipe(process.stdout);
+    ps.stderr.pipe(process.stdout);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        if (line.length === 0) return;
+        
+        run(files.bundle, function (err, output) {
+            t.ifError(err);
+            t.equal(output, expected.shift());
+            
+            (function next () {
+                if (edits.length === 0) return;
+                var edit = edits.shift();
+                setTimeout(function () {
+                    fs.writeFile(files[edit.file], edit.source, function (err) {
+                        t.ifError(err);
+                        if (edit.next) next();
+                    });
+                }, 25);
+            })();
+        })
+    });
+    
+    t.on('end', function () {
+        ps.kill();
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/many_immediate.js

@@ -0,0 +1,99 @@
+var test = require('tape');
+var fs = require('fs');
+var path = require('path');
+var mkdirp = require('mkdirp');
+var spawn = require('win-spawn');
+var split = require('split');
+
+var cmd = path.resolve(__dirname, '../bin/cmd.js');
+var os = require('os');
+var tmpdir = path.join((os.tmpdir || os.tmpDir)(), 'watchify-' + Math.random());
+
+var files = {
+    main: path.join(tmpdir, 'main.js'),
+    robot: path.join(tmpdir, 'robot.js'),
+    lines: path.join(tmpdir, 'lines.txt'),
+    bundle: path.join(tmpdir, 'bundle.js')
+};
+
+var edits = [
+    { file: 'lines', source: 'robo-boogie' },
+    { file: 'lines', source: 'dinosaurus rex' },
+    {
+        file: 'robot',
+        source: 'module.exports = function (n) { return n * 111 }',
+        next: true
+    },
+    { file: 'main', source: [
+        'var fs = require("fs");',
+        'var robot = require("./robot.js");',
+        'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+        'console.log(src.toUpperCase() + " " + robot(src.length));'
+    ].join('\n') },
+    { file: 'lines', source: 't-rex' },
+    {
+        file: 'robot',
+        source: 'module.exports = function (n) { return n * 100 }',
+    }
+];
+
+var expected = [
+    'BEEP\nBOOP\n',
+    'ROBO-BOOGIE\n',
+    'DINOSAURUS REX\n',
+    'DINOSAURUS REX 1554\n',
+    'T-REX 555\n',
+    'T-REX 500\n'
+];
+
+mkdirp.sync(tmpdir);
+fs.writeFileSync(files.main, [
+    'var fs = require("fs");',
+    'var src = fs.readFileSync(__dirname + "/lines.txt", "utf8");',
+    'console.log(src.toUpperCase());'
+].join('\n'));
+fs.writeFileSync(files.lines, 'beep\nboop');
+
+test('many immediate', function (t) {
+    t.plan(expected.length * 2 + edits.length);
+    var ps = spawn(cmd, [
+        files.main,
+        '-t', require.resolve('brfs'), '-v',
+        '-o', files.bundle
+    ]);
+    ps.stdout.pipe(process.stdout);
+    ps.stderr.pipe(process.stdout);
+    var lineNum = 0;
+    ps.stderr.pipe(split()).on('data', function (line) {
+        if (line.length === 0) return;
+        
+        run(files.bundle, function (err, output) {
+            t.ifError(err);
+            t.equal(output, expected.shift());
+            
+            (function next () {
+                if (edits.length === 0) return;
+                var edit = edits.shift();
+                fs.writeFile(files[edit.file], edit.source, function (err) {
+                    t.ifError(err);
+                    if (edit.next) next();
+                });
+            })();
+        })
+    });
+    
+    t.on('end', function () {
+        ps.kill();
+    });
+});
+
+function run (file, cb) {
+    var ps = spawn(process.execPath, [ file ]);
+    var data = [];
+    ps.stdout.on('data', function (buf) { data.push(buf) });
+    ps.stdout.on('end', function () {
+        cb(null, Buffer.concat(data).toString('utf8'));
+    });
+    ps.on('error', cb);
+    return ps;
+}

node_modules/watchify/test/zzz.js

@@ -0,0 +1,10 @@
+var test = require('tape');
+
+test('__END__', function (t) {
+    t.on('end', function () {
+        setTimeout(function () {
+            process.exit(0);
+        }, 100)
+    });
+    t.end();
+});