updated readme

node_modules/optimist/test/_.js

@@ -0,0 +1,66 @@
+var spawn = require('child_process').spawn;
+var assert = require('assert');
+
+exports.dotSlashEmpty = function () {
+    testCmd('./bin.js', []);
+};
+
+exports.dotSlashArgs = function () {
+    testCmd('./bin.js', [ 'a', 'b', 'c' ]);
+};
+
+exports.nodeEmpty = function () {
+    testCmd('node bin.js', []);
+};
+
+exports.nodeArgs = function () {
+    testCmd('node bin.js', [ 'x', 'y', 'z' ]);
+};
+
+exports.whichNodeEmpty = function () {
+    var which = spawn('which', ['node']);
+    
+    which.stdout.on('data', function (buf) {
+        testCmd(buf.toString().trim() + ' bin.js', []);
+    });
+    
+    which.stderr.on('data', function (err) {
+        assert.fail(err.toString());
+    });
+};
+
+exports.whichNodeArgs = function () {
+    var which = spawn('which', ['node']);
+    
+    which.stdout.on('data', function (buf) {
+        testCmd(buf.toString().trim() + ' bin.js', [ 'q', 'r' ]);
+    });
+    
+    which.stderr.on('data', function (err) {
+        assert.fail(err.toString());
+    });
+};
+
+function testCmd (cmd, args) {
+    var to = setTimeout(function () {
+        assert.fail('Never got stdout data.')
+    }, 5000);
+    
+    var oldDir = process.cwd();
+    process.chdir(__dirname + '/_');
+    
+    var cmds = cmd.split(' ');
+    
+    var bin = spawn(cmds[0], cmds.slice(1).concat(args.map(String)));
+    process.chdir(oldDir);
+    
+    bin.stderr.on('data', function (err) {
+        assert.fail(err.toString());
+    });
+    
+    bin.stdout.on('data', function (buf) {
+        clearTimeout(to);
+        var _ = JSON.parse(buf.toString());
+        assert.eql(_.map(String), args.map(String));
+    });
+}

node_modules/optimist/test/_/argv.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+console.log(JSON.stringify(process.argv));

node_modules/optimist/test/_/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+var argv = require('../../index').argv
+console.log(JSON.stringify(argv._));

node_modules/optimist/test/parse.js

@@ -0,0 +1,304 @@
+var optimist = require('../index');
+var assert = require('assert');
+var path = require('path');
+
+var localExpresso = path.normalize(
+    __dirname + '/../node_modules/.bin/expresso'
+);
+
+var expresso = process.argv[1] === localExpresso
+    ? 'node ./node_modules/.bin/expresso'
+    : 'expresso'
+;
+
+exports['short boolean'] = function () {
+    var parse = optimist.parse([ '-b' ]);
+    assert.eql(parse, { b : true, _ : [], $0 : expresso });
+    assert.eql(typeof parse.b, 'boolean');
+};
+
+exports['long boolean'] = function () {
+    assert.eql(
+        optimist.parse([ '--bool' ]),
+        { bool : true, _ : [], $0 : expresso }
+    );
+};
+    
+exports.bare = function () {
+    assert.eql(
+        optimist.parse([ 'foo', 'bar', 'baz' ]),
+        { _ : [ 'foo', 'bar', 'baz' ], $0 : expresso }
+    );
+};
+
+exports['short group'] = function () {
+    assert.eql(
+        optimist.parse([ '-cats' ]),
+        { c : true, a : true, t : true, s : true, _ : [], $0 : expresso }
+    );
+};
+
+exports['short group next'] = function () {
+    assert.eql(
+        optimist.parse([ '-cats', 'meow' ]),
+        { c : true, a : true, t : true, s : 'meow', _ : [], $0 : expresso }
+    );
+};
+ 
+exports['short capture'] = function () {
+    assert.eql(
+        optimist.parse([ '-h', 'localhost' ]),
+        { h : 'localhost', _ : [], $0 : expresso }
+    );
+};
+
+exports['short captures'] = function () {
+    assert.eql(
+        optimist.parse([ '-h', 'localhost', '-p', '555' ]),
+        { h : 'localhost', p : 555, _ : [], $0 : expresso }
+    );
+};
+
+exports['long capture sp'] = function () {
+    assert.eql(
+        optimist.parse([ '--pow', 'xixxle' ]),
+        { pow : 'xixxle', _ : [], $0 : expresso }
+    );
+};
+
+exports['long capture eq'] = function () {
+    assert.eql(
+        optimist.parse([ '--pow=xixxle' ]),
+        { pow : 'xixxle', _ : [], $0 : expresso }
+    );
+};
+
+exports['long captures sp'] = function () {
+    assert.eql(
+        optimist.parse([ '--host', 'localhost', '--port', '555' ]),
+        { host : 'localhost', port : 555, _ : [], $0 : expresso }
+    );
+};
+
+exports['long captures eq'] = function () {
+    assert.eql(
+        optimist.parse([ '--host=localhost', '--port=555' ]),
+        { host : 'localhost', port : 555, _ : [], $0 : expresso }
+    );
+};
+
+exports['mixed short bool and capture'] = function () {
+    assert.eql(
+        optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
+        {
+            f : true, p : 555, h : 'localhost',
+            _ : [ 'script.js' ], $0 : expresso,
+        }
+    );
+};
+ 
+exports['short and long'] = function () {
+    assert.eql(
+        optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
+        {
+            f : true, p : 555, h : 'localhost',
+            _ : [ 'script.js' ], $0 : expresso,
+        }
+    );
+};
+
+exports.no = function () {
+    assert.eql(
+        optimist.parse([ '--no-moo' ]),
+        { moo : false, _ : [], $0 : expresso }
+    );
+};
+ 
+exports.multi = function () {
+    assert.eql(
+        optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
+        { v : ['a','b','c'], _ : [], $0 : expresso }
+    );
+};
+ 
+exports.comprehensive = function () {
+    assert.eql(
+        optimist.parse([
+            '--name=meowmers', 'bare', '-cats', 'woo',
+            '-h', 'awesome', '--multi=quux',
+            '--key', 'value',
+            '-b', '--bool', '--no-meep', '--multi=baz',
+            '--', '--not-a-flag', 'eek'
+        ]),
+        {
+            c : true,
+            a : true,
+            t : true,
+            s : 'woo',
+            h : 'awesome',
+            b : true,
+            bool : true,
+            key : 'value',
+            multi : [ 'quux', 'baz' ],
+            meep : false,
+            name : 'meowmers',
+            _ : [ 'bare', '--not-a-flag', 'eek' ],
+            $0 : expresso
+        }
+    );
+};
+
+exports.nums = function () {
+    var argv = optimist.parse([
+        '-x', '1234',
+        '-y', '5.67',
+        '-z', '1e7',
+        '-w', '10f',
+        '--hex', '0xdeadbeef',
+        '789',
+    ]);
+    assert.eql(argv, {
+        x : 1234,
+        y : 5.67,
+        z : 1e7,
+        w : '10f',
+        hex : 0xdeadbeef,
+        _ : [ 789 ],
+        $0 : expresso
+    });
+    assert.eql(typeof argv.x, 'number');
+    assert.eql(typeof argv.y, 'number');
+    assert.eql(typeof argv.z, 'number');
+    assert.eql(typeof argv.w, 'string');
+    assert.eql(typeof argv.hex, 'number');
+    assert.eql(typeof argv._[0], 'number');
+};
+
+exports['flag boolean'] = function () {
+    var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv;
+    assert.eql(parse, { t : true, _ : [ 'moo' ], $0 : expresso });
+    assert.eql(typeof parse.t, 'boolean');
+};
+
+exports['flag boolean value'] = function () {
+    var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true'])
+        .boolean(['t', 'verbose']).default('verbose', true).argv;
+    
+    assert.eql(parse, {
+        verbose: false,
+        t: true,
+        _: ['moo'],
+        $0 : expresso
+    });
+    
+    assert.eql(typeof parse.verbose, 'boolean');
+    assert.eql(typeof parse.t, 'boolean');
+};
+
+exports['flag boolean default false'] = function () {
+    var parse = optimist(['moo'])
+        .boolean(['t', 'verbose'])
+        .default('verbose', false)
+        .default('t', false).argv;
+    
+    assert.eql(parse, {
+        verbose: false,
+        t: false,
+        _: ['moo'],
+        $0 : expresso
+    });
+    
+    assert.eql(typeof parse.verbose, 'boolean');
+    assert.eql(typeof parse.t, 'boolean');
+    
+};
+
+exports['boolean groups'] = function () {
+    var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ])
+        .boolean(['x','y','z']).argv;
+    
+    assert.eql(parse, {
+        x : true,
+        y : false,
+        z : true,
+        _ : [ 'one', 'two', 'three' ],
+        $0 : expresso
+    });
+    
+    assert.eql(typeof parse.x, 'boolean');
+    assert.eql(typeof parse.y, 'boolean');
+    assert.eql(typeof parse.z, 'boolean');
+};
+
+exports.strings = function () {
+    var s = optimist([ '-s', '0001234' ]).string('s').argv.s;
+    assert.eql(s, '0001234');
+    assert.eql(typeof s, 'string');
+    
+    var x = optimist([ '-x', '56' ]).string('x').argv.x;
+    assert.eql(x, '56');
+    assert.eql(typeof x, 'string');
+};
+
+exports.stringArgs = function () {
+    var s = optimist([ '  ', '  ' ]).string('_').argv._;
+    assert.eql(s.length, 2);
+    assert.eql(typeof s[0], 'string');
+    assert.eql(s[0], '  ');
+    assert.eql(typeof s[1], 'string');
+    assert.eql(s[1], '  ');
+};
+
+exports.slashBreak = function () {
+    assert.eql(
+        optimist.parse([ '-I/foo/bar/baz' ]),
+        { I : '/foo/bar/baz', _ : [], $0 : expresso }
+    );
+    assert.eql(
+        optimist.parse([ '-xyz/foo/bar/baz' ]),
+        { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : expresso }
+    );
+};
+
+exports.alias = function () {
+    var argv = optimist([ '-f', '11', '--zoom', '55' ])
+        .alias('z', 'zoom')
+        .argv
+    ;
+    assert.equal(argv.zoom, 55);
+    assert.equal(argv.z, argv.zoom);
+    assert.equal(argv.f, 11);
+};
+
+exports.multiAlias = function () {
+    var argv = optimist([ '-f', '11', '--zoom', '55' ])
+        .alias('z', [ 'zm', 'zoom' ])
+        .argv
+    ;
+    assert.equal(argv.zoom, 55);
+    assert.equal(argv.z, argv.zoom);
+    assert.equal(argv.z, argv.zm);
+    assert.equal(argv.f, 11);
+};
+
+exports['boolean default true'] = function () {
+    var argv = optimist.options({
+        sometrue: {
+            boolean: true,
+            default: true
+        }
+    }).argv;
+  
+    assert.equal(argv.sometrue, true);
+};
+
+exports['boolean default false'] = function () {
+    var argv = optimist.options({
+        somefalse: {
+            boolean: true,
+            default: false
+        }
+    }).argv;
+
+    assert.equal(argv.somefalse, false);
+};

node_modules/optimist/test/usage.js

@@ -0,0 +1,256 @@
+var Hash = require('hashish');
+var optimist = require('../index');
+var assert = require('assert');
+
+exports.usageFail = function () {
+    var r = checkUsage(function () {
+        return optimist('-x 10 -z 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .demand(['x','y'])
+            .argv;
+    });
+    assert.deepEqual(
+        r.result,
+        { x : 10, z : 20, _ : [], $0 : './usage' }
+    );
+    
+    assert.deepEqual(
+        r.errors.join('\n').split(/\n+/),
+        [
+            'Usage: ./usage -x NUM -y NUM',
+            'Options:',
+            '  -x  [required]',
+            '  -y  [required]',
+            'Missing required arguments: y',
+        ]
+    );
+    assert.deepEqual(r.logs, []);
+    assert.ok(r.exit);
+};
+
+exports.usagePass = function () {
+    var r = checkUsage(function () {
+        return optimist('-x 10 -y 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .demand(['x','y'])
+            .argv;
+    });
+    assert.deepEqual(r, {
+        result : { x : 10, y : 20, _ : [], $0 : './usage' },
+        errors : [],
+        logs : [],
+        exit : false,
+    });
+};
+
+exports.checkPass = function () {
+    var r = checkUsage(function () {
+        return optimist('-x 10 -y 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .check(function (argv) {
+                if (!('x' in argv)) throw 'You forgot about -x';
+                if (!('y' in argv)) throw 'You forgot about -y';
+            })
+            .argv;
+    });
+    assert.deepEqual(r, {
+        result : { x : 10, y : 20, _ : [], $0 : './usage' },
+        errors : [],
+        logs : [],
+        exit : false,
+    });
+};
+
+exports.checkFail = function () {
+    var r = checkUsage(function () {
+        return optimist('-x 10 -z 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .check(function (argv) {
+                if (!('x' in argv)) throw 'You forgot about -x';
+                if (!('y' in argv)) throw 'You forgot about -y';
+            })
+            .argv;
+    });
+    
+    assert.deepEqual(
+        r.result,
+        { x : 10, z : 20, _ : [], $0 : './usage' }
+    );
+    
+    assert.deepEqual(
+        r.errors.join('\n').split(/\n+/),
+        [
+            'Usage: ./usage -x NUM -y NUM',
+            'You forgot about -y'
+        ]
+    );
+    
+    assert.deepEqual(r.logs, []);
+    assert.ok(r.exit);
+};
+
+exports.checkCondPass = function () {
+    function checker (argv) {
+        return 'x' in argv && 'y' in argv;
+    }
+    
+    var r = checkUsage(function () {
+        return optimist('-x 10 -y 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .check(checker)
+            .argv;
+    });
+    assert.deepEqual(r, {
+        result : { x : 10, y : 20, _ : [], $0 : './usage' },
+        errors : [],
+        logs : [],
+        exit : false,
+    });
+};
+
+exports.checkCondFail = function () {
+    function checker (argv) {
+        return 'x' in argv && 'y' in argv;
+    }
+    
+    var r = checkUsage(function () {
+        return optimist('-x 10 -z 20'.split(' '))
+            .usage('Usage: $0 -x NUM -y NUM')
+            .check(checker)
+            .argv;
+    });
+    
+    assert.deepEqual(
+        r.result,
+        { x : 10, z : 20, _ : [], $0 : './usage' }
+    );
+    
+    assert.deepEqual(
+        r.errors.join('\n').split(/\n+/).join('\n'),
+        'Usage: ./usage -x NUM -y NUM\n'
+        + 'Argument check failed: ' + checker.toString()
+    );
+    
+    assert.deepEqual(r.logs, []);
+    assert.ok(r.exit);
+};
+
+exports.countPass = function () {
+    var r = checkUsage(function () {
+        return optimist('1 2 3 --moo'.split(' '))
+            .usage('Usage: $0 [x] [y] [z] {OPTIONS}')
+            .demand(3)
+            .argv;
+    });
+    assert.deepEqual(r, {
+        result : { _ : [ '1', '2', '3' ], moo : true, $0 : './usage' },
+        errors : [],
+        logs : [],
+        exit : false,
+    });
+};
+
+exports.countFail = function () {
+    var r = checkUsage(function () {
+        return optimist('1 2 --moo'.split(' '))
+            .usage('Usage: $0 [x] [y] [z] {OPTIONS}')
+            .demand(3)
+            .argv;
+    });
+    assert.deepEqual(
+        r.result,
+        { _ : [ '1', '2' ], moo : true, $0 : './usage' }
+    );
+    
+    assert.deepEqual(
+        r.errors.join('\n').split(/\n+/),
+        [
+            'Usage: ./usage [x] [y] [z] {OPTIONS}',
+            'Not enough non-option arguments: got 2, need at least 3',
+        ]
+    );
+    
+    assert.deepEqual(r.logs, []);
+    assert.ok(r.exit);
+};
+
+exports.defaultSingles = function () {
+    var r = checkUsage(function () {
+        return optimist('--foo 50 --baz 70 --powsy'.split(' '))
+            .default('foo', 5)
+            .default('bar', 6)
+            .default('baz', 7)
+            .argv
+        ;
+    });
+    assert.eql(r.result, {
+        foo : '50',
+        bar : 6,
+        baz : '70',
+        powsy : true,
+        _ : [],
+        $0 : './usage',
+    });
+};
+
+exports.defaultHash = function () {
+    var r = checkUsage(function () {
+        return optimist('--foo 50 --baz 70'.split(' '))
+            .default({ foo : 10, bar : 20, quux : 30 })
+            .argv
+        ;
+    });
+    assert.eql(r.result, {
+        foo : '50',
+        bar : 20,
+        baz : 70,
+        quux : 30,
+        _ : [],
+        $0 : './usage',
+    });
+};
+
+exports.rebase = function () {
+    assert.equal(
+        optimist.rebase('/home/substack', '/home/substack/foo/bar/baz'),
+        './foo/bar/baz'
+    );
+    assert.equal(
+        optimist.rebase('/home/substack/foo/bar/baz', '/home/substack'),
+        '../../..'
+    );
+    assert.equal(
+        optimist.rebase('/home/substack/foo', '/home/substack/pow/zoom.txt'),
+        '../pow/zoom.txt'
+    );
+};
+
+function checkUsage (f) {
+    var _process = process;
+    process = Hash.copy(process);
+    var exit = false;
+    process.exit = function () { exit = true };
+    process.env = Hash.merge(process.env, { _ : 'node' });
+    process.argv = [ './usage' ];
+    
+    var errors = [];
+    var logs = [];
+    
+    console._error = console.error;
+    console.error = function (msg) { errors.push(msg) };
+    console._log = console.log;
+    console.log = function (msg) { logs.push(msg) };
+    
+    var result = f();
+    
+    process = _process;
+    console.error = console._error;
+    console.log = console._log;
+    
+    return {
+        errors : errors,
+        logs : logs,
+        exit : exit,
+        result : result,
+    };
+};