finally works

node_modules/optimist/.gitignore

@@ -1,2 +0,0 @@
-node_modules/
-node_modules/*

node_modules/optimist/.npmignore

@@ -1,4 +0,0 @@
-lib-cov/*
-*.swp
-*.swo
-node_modules

node_modules/optimist/README.markdown

@@ -7,6 +7,8 @@ and -whistlz of program usage but think optstrings are a waste of time.
 
 With optimist, option parsing doesn't have to suck (as much).
 
+[![build status](https://secure.travis-ci.org/substack/node-optimist.png)](http://travis-ci.org/substack/node-optimist)
+
 examples
 ========
 
@@ -452,6 +454,17 @@ all the values in order.
       '$0': 'node ./examples/reflect.js',
         x: [ 5, 8, 0 ] }
 
+dot notation
+------------
+
+When you use dots (`.`s) in argument names, an implicit object path is assumed.
+This lets you organize arguments into nested objects.
+
+     $ node examples/reflect.js --foo.bar.baz=33 --foo.quux=5
+     { _: [],
+       '$0': 'node ./examples/reflect.js',
+         foo: { bar: { baz: 33 }, quux: 5 } }
+
 installation
 ============
 

node_modules/optimist/examples/bool.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-var util = require('util');
-var argv = require('optimist').argv;
-
-if (argv.s) {
-    util.print(argv.fr ? 'Le chat dit: ' : 'The cat says: ');
-}
-console.log(
-    (argv.fr ? 'miaou' : 'meow') + (argv.p ? '.' : '')
-);

node_modules/optimist/examples/boolean_double.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .boolean(['x','y','z'])
-    .argv
-;
-console.dir([ argv.x, argv.y, argv.z ]);
-console.dir(argv._);

node_modules/optimist/examples/boolean_single.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .boolean('v')
-    .argv
-;
-console.dir(argv.v);
-console.dir(argv._);

node_modules/optimist/examples/default_hash.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-var argv = require('optimist')
-    .default({ x : 10, y : 10 })
-    .argv
-;
-
-console.log(argv.x + argv.y);

node_modules/optimist/examples/default_singles.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .default('x', 10)
-    .default('y', 10)
-    .argv
-;
-console.log(argv.x + argv.y);

node_modules/optimist/examples/divide.js

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-
-var argv = require('optimist')
-    .usage('Usage: $0 -x [num] -y [num]')
-    .demand(['x','y'])
-    .argv;
-
-console.log(argv.x / argv.y);

node_modules/optimist/examples/line_count.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .usage('Count the lines in a file.\nUsage: $0')
-    .demand('f')
-    .alias('f', 'file')
-    .describe('f', 'Load a file')
-    .argv
-;
-
-var fs = require('fs');
-var s = fs.createReadStream(argv.file);
-
-var lines = 0;
-s.on('data', function (buf) {
-    lines += buf.toString().match(/\n/g).length;
-});
-
-s.on('end', function () {
-    console.log(lines);
-});

node_modules/optimist/examples/line_count_options.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .usage('Count the lines in a file.\nUsage: $0')
-    .options({
-        file : {
-            demand : true,
-            alias : 'f',
-            description : 'Load a file'
-        },
-        base : {
-            alias : 'b',
-            description : 'Numeric base to use for output',
-            default : 10,
-        },
-    })
-    .argv
-;
-
-var fs = require('fs');
-var s = fs.createReadStream(argv.file);
-
-var lines = 0;
-s.on('data', function (buf) {
-    lines += buf.toString().match(/\n/g).length;
-});
-
-s.on('end', function () {
-    console.log(lines.toString(argv.base));
-});

node_modules/optimist/examples/line_count_wrap.js

@@ -1,29 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .usage('Count the lines in a file.\nUsage: $0')
-    .wrap(80)
-    .demand('f')
-    .alias('f', [ 'file', 'filename' ])
-    .describe('f',
-        "Load a file. It's pretty important."
-        + " Required even. So you'd better specify it."
-    )
-    .alias('b', 'base')
-    .describe('b', 'Numeric base to display the number of lines in')
-    .default('b', 10)
-    .describe('x', 'Super-secret optional parameter which is secret')
-    .default('x', '')
-    .argv
-;
-
-var fs = require('fs');
-var s = fs.createReadStream(argv.file);
-
-var lines = 0;
-s.on('data', function (buf) {
-    lines += buf.toString().match(/\n/g).length;
-});
-
-s.on('end', function () {
-    console.log(lines.toString(argv.base));
-});

node_modules/optimist/examples/nonopt.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist').argv;
-console.log('(%d,%d)', argv.x, argv.y);
-console.log(argv._);

node_modules/optimist/examples/reflect.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.dir(require('optimist').argv);

node_modules/optimist/examples/short.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist').argv;
-console.log('(%d,%d)', argv.x, argv.y);

node_modules/optimist/examples/string.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist')
-    .string('x', 'y')
-    .argv
-;
-console.dir([ argv.x, argv.y ]);
-
-/* Turns off numeric coercion:
-    ./node string.js -x 000123 -y 9876
-    [ '000123', '9876' ]
-*/

node_modules/optimist/examples/usage-options.js

@@ -1,19 +0,0 @@
-var optimist = require('./../index');
-
-var argv = optimist.usage('This is my awesome program', {
-  'about': {
-    description: 'Provide some details about the author of this program',
-    required: true,
-    short: 'a',
-  },
-  'info': {
-    description: 'Provide some information about the node.js agains!!!!!!',
-    boolean: true,
-    short: 'i'
-  }
-}).argv;
-
-optimist.showHelp();
-
-console.log('\n\nInspecting options');
-console.dir(argv);

node_modules/optimist/examples/xup.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-var argv = require('optimist').argv;
-
-if (argv.rif - 5 * argv.xup > 7.138) {
-    console.log('Buy more riffiwobbles');
-}
-else {
-    console.log('Sell the xupptumblers');
-}
-

node_modules/optimist/index.js

@@ -168,7 +168,9 @@ function Argv (args, cwd) {
         else {
             if (opt.alias) self.alias(key, opt.alias);
             if (opt.demand) self.demand(key);
-            if (opt.default) self.default(key, opt.default);
+            if (typeof opt.default !== 'undefined') {
+                self.default(key, opt.default);
+            }
             
             if (opt.boolean || opt.type === 'boolean') {
                 self.boolean(key);
@@ -311,15 +313,7 @@ function Argv (args, cwd) {
             var value = typeof val !== 'string' || isNaN(num) ? val : num;
             if (flags.strings[key]) value = val;
             
-            if (key in argv && !flags.bools[key]) {
-                if (!Array.isArray(argv[key])) {
-                    argv[key] = [ argv[key] ];
-                }
-                argv[key].push(value);
-            }
-            else {
-                argv[key] = value;
-            }
+            setKey(argv, key.split('.'), value);
             
             (aliases[key] || []).forEach(function (x) {
                 argv[x] = argv[key];
@@ -345,11 +339,12 @@ function Argv (args, cwd) {
                 var key = arg.match(/^--(.+)/)[1];
                 var next = args[i + 1];
                 if (next !== undefined && !next.match(/^-/)
-                && !flags.bools[key]) {
+                && !flags.bools[key]
+                && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
                     setArg(key, next);
                     i++;
                 }
-                else if (flags.bools[key] && /true|false/.test(next)) {
+                else if (/^(true|false)$/.test(next)) {
                     setArg(key, next === 'true');
                     i++;
                 }
@@ -376,11 +371,12 @@ function Argv (args, cwd) {
                     var key = arg.slice(-1)[0];
                     
                     if (args[i+1] && !args[i+1].match(/^-/)
-                    && !flags.bools[key]) {
+                    && !flags.bools[key]
+                    && (aliases[key] ? !flags.bools[aliases[key]] : true)) {
                         setArg(key, args[i+1]);
                         i++;
                     }
-                    else if (args[i+1] && flags.bools[key] && /true|false/.test(args[i+1])) {
+                    else if (args[i+1] && /true|false/.test(args[i+1])) {
                         setArg(key, args[i+1] === 'true');
                         i++;
                     }
@@ -398,6 +394,9 @@ function Argv (args, cwd) {
         Object.keys(defaults).forEach(function (key) {
             if (!(key in argv)) {
                 argv[key] = defaults[key];
+                if (key in aliases) {
+                    argv[aliases[key]] = defaults[key];
+                }
             }
         });
         
@@ -455,3 +454,22 @@ function rebase (base, dir) {
     ).replace(/\/$/,'').replace(/^$/, '.');
     return p.match(/^[.\/]/) ? p : './' + p;
 };
+
+function setKey (obj, keys, value) {
+    var o = obj;
+    keys.slice(0,-1).forEach(function (key) {
+        if (o[key] === undefined) o[key] = {};
+        o = o[key];
+    });
+    
+    var key = keys[keys.length - 1];
+    if (o[key] === undefined || typeof o[key] === 'boolean') {
+        o[key] = value;
+    }
+    else if (Array.isArray(o[key])) {
+        o[key].push(value);
+    }
+    else {
+        o[key] = [ o[key], value ];
+    }
+}

node_modules/optimist/test/_.js

@@ -1,66 +1,71 @@
 var spawn = require('child_process').spawn;
-var assert = require('assert');
+var test = require('tap').test;
 
-exports.dotSlashEmpty = function () {
-    testCmd('./bin.js', []);
-};
+test('dotSlashEmpty', testCmd('./bin.js', []));
 
-exports.dotSlashArgs = function () {
-    testCmd('./bin.js', [ 'a', 'b', 'c' ]);
-};
+test('dotSlashArgs', testCmd('./bin.js', [ 'a', 'b', 'c' ]));
 
-exports.nodeEmpty = function () {
-    testCmd('node bin.js', []);
-};
+test('nodeEmpty', testCmd('node bin.js', []));
 
-exports.nodeArgs = function () {
-    testCmd('node bin.js', [ 'x', 'y', 'z' ]);
-};
+test('nodeArgs', testCmd('node bin.js', [ 'x', 'y', 'z' ]));
 
-exports.whichNodeEmpty = function () {
+test('whichNodeEmpty', function (t) {
     var which = spawn('which', ['node']);
     
     which.stdout.on('data', function (buf) {
-        testCmd(buf.toString().trim() + ' bin.js', []);
+        t.test(
+            testCmd(buf.toString().trim() + ' bin.js', [])
+        );
+        t.end();
     });
     
     which.stderr.on('data', function (err) {
-        assert.fail(err.toString());
+        assert.error(err);
+        t.end();
     });
-};
+});
 
-exports.whichNodeArgs = function () {
+test('whichNodeArgs', function (t) {
     var which = spawn('which', ['node']);
-    
+
     which.stdout.on('data', function (buf) {
-        testCmd(buf.toString().trim() + ' bin.js', [ 'q', 'r' ]);
+        t.test(
+            testCmd(buf.toString().trim() + ' bin.js', [ 'q', 'r' ])
+        );
+        t.end();
     });
     
     which.stderr.on('data', function (err) {
-        assert.fail(err.toString());
+        t.error(err);
+        t.end();
     });
-};
+});
 
 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));
-    });
+
+    return function (t) {
+        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) {
+            t.error(err);
+            t.end();
+        });
+        
+        bin.stdout.on('data', function (buf) {
+            clearTimeout(to);
+            var _ = JSON.parse(buf.toString());
+            t.same(_.map(String), args.map(String));
+            t.end();
+        });
+    };
 }

node_modules/optimist/test/parse.js

@@ -1,128 +1,136 @@
 var optimist = require('../index');
-var assert = require('assert');
 var path = require('path');
+var test = require('tap').test;
 
-var localExpresso = path.normalize(
-    __dirname + '/../node_modules/.bin/expresso'
-);
+var $0 = 'node ./' + path.relative(process.cwd(), __filename);
 
-var expresso = process.argv[1] === localExpresso
-    ? 'node ./node_modules/.bin/expresso'
-    : 'expresso'
-;
-
-exports['short boolean'] = function () {
+test('short boolean', function (t) {
     var parse = optimist.parse([ '-b' ]);
-    assert.eql(parse, { b : true, _ : [], $0 : expresso });
-    assert.eql(typeof parse.b, 'boolean');
-};
+    t.same(parse, { b : true, _ : [], $0 : $0 });
+    t.same(typeof parse.b, 'boolean');
+    t.end();
+});
 
-exports['long boolean'] = function () {
-    assert.eql(
+test('long boolean', function (t) {
+    t.same(
         optimist.parse([ '--bool' ]),
-        { bool : true, _ : [], $0 : expresso }
+        { bool : true, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
     
-exports.bare = function () {
-    assert.eql(
+test('bare', function (t) {
+    t.same(
         optimist.parse([ 'foo', 'bar', 'baz' ]),
-        { _ : [ 'foo', 'bar', 'baz' ], $0 : expresso }
+        { _ : [ 'foo', 'bar', 'baz' ], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['short group'] = function () {
-    assert.eql(
+test('short group', function (t) {
+    t.same(
         optimist.parse([ '-cats' ]),
-        { c : true, a : true, t : true, s : true, _ : [], $0 : expresso }
+        { c : true, a : true, t : true, s : true, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['short group next'] = function () {
-    assert.eql(
+test('short group next', function (t) {
+    t.same(
         optimist.parse([ '-cats', 'meow' ]),
-        { c : true, a : true, t : true, s : 'meow', _ : [], $0 : expresso }
+        { c : true, a : true, t : true, s : 'meow', _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
  
-exports['short capture'] = function () {
-    assert.eql(
+test('short capture', function (t) {
+    t.same(
         optimist.parse([ '-h', 'localhost' ]),
-        { h : 'localhost', _ : [], $0 : expresso }
+        { h : 'localhost', _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['short captures'] = function () {
-    assert.eql(
+test('short captures', function (t) {
+    t.same(
         optimist.parse([ '-h', 'localhost', '-p', '555' ]),
-        { h : 'localhost', p : 555, _ : [], $0 : expresso }
+        { h : 'localhost', p : 555, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['long capture sp'] = function () {
-    assert.eql(
+test('long capture sp', function (t) {
+    t.same(
         optimist.parse([ '--pow', 'xixxle' ]),
-        { pow : 'xixxle', _ : [], $0 : expresso }
+        { pow : 'xixxle', _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['long capture eq'] = function () {
-    assert.eql(
+test('long capture eq', function (t) {
+    t.same(
         optimist.parse([ '--pow=xixxle' ]),
-        { pow : 'xixxle', _ : [], $0 : expresso }
+        { pow : 'xixxle', _ : [], $0 : $0 }
     );
-};
+    t.end()
+});
 
-exports['long captures sp'] = function () {
-    assert.eql(
+test('long captures sp', function (t) {
+    t.same(
         optimist.parse([ '--host', 'localhost', '--port', '555' ]),
-        { host : 'localhost', port : 555, _ : [], $0 : expresso }
+        { host : 'localhost', port : 555, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['long captures eq'] = function () {
-    assert.eql(
+test('long captures eq', function (t) {
+    t.same(
         optimist.parse([ '--host=localhost', '--port=555' ]),
-        { host : 'localhost', port : 555, _ : [], $0 : expresso }
+        { host : 'localhost', port : 555, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports['mixed short bool and capture'] = function () {
-    assert.eql(
+test('mixed short bool and capture', function (t) {
+    t.same(
         optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
         {
             f : true, p : 555, h : 'localhost',
-            _ : [ 'script.js' ], $0 : expresso,
+            _ : [ 'script.js' ], $0 : $0,
         }
     );
-};
+    t.end();
+});
  
-exports['short and long'] = function () {
-    assert.eql(
+test('short and long', function (t) {
+    t.same(
         optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
         {
             f : true, p : 555, h : 'localhost',
-            _ : [ 'script.js' ], $0 : expresso,
+            _ : [ 'script.js' ], $0 : $0,
         }
     );
-};
+    t.end();
+});
 
-exports.no = function () {
-    assert.eql(
+test('no', function (t) {
+    t.same(
         optimist.parse([ '--no-moo' ]),
-        { moo : false, _ : [], $0 : expresso }
+        { moo : false, _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
  
-exports.multi = function () {
-    assert.eql(
+test('multi', function (t) {
+    t.same(
         optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
-        { v : ['a','b','c'], _ : [], $0 : expresso }
+        { v : ['a','b','c'], _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
  
-exports.comprehensive = function () {
-    assert.eql(
+test('comprehensive', function (t) {
+    t.same(
         optimist.parse([
             '--name=meowmers', 'bare', '-cats', 'woo',
             '-h', 'awesome', '--multi=quux',
@@ -143,12 +151,13 @@ exports.comprehensive = function () {
             meep : false,
             name : 'meowmers',
             _ : [ 'bare', '--not-a-flag', 'eek' ],
-            $0 : expresso
+            $0 : $0
         }
     );
-};
+    t.end();
+});
 
-exports.nums = function () {
+test('nums', function (t) {
     var argv = optimist.parse([
         '-x', '1234',
         '-y', '5.67',
@@ -157,131 +166,141 @@ exports.nums = function () {
         '--hex', '0xdeadbeef',
         '789',
     ]);
-    assert.eql(argv, {
+    t.same(argv, {
         x : 1234,
         y : 5.67,
         z : 1e7,
         w : '10f',
         hex : 0xdeadbeef,
         _ : [ 789 ],
-        $0 : expresso
+        $0 : $0
     });
-    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');
-};
+    t.same(typeof argv.x, 'number');
+    t.same(typeof argv.y, 'number');
+    t.same(typeof argv.z, 'number');
+    t.same(typeof argv.w, 'string');
+    t.same(typeof argv.hex, 'number');
+    t.same(typeof argv._[0], 'number');
+    t.end();
+});
 
-exports['flag boolean'] = function () {
+test('flag boolean', function (t) {
     var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv;
-    assert.eql(parse, { t : true, _ : [ 'moo' ], $0 : expresso });
-    assert.eql(typeof parse.t, 'boolean');
-};
+    t.same(parse, { t : true, _ : [ 'moo' ], $0 : $0 });
+    t.same(typeof parse.t, 'boolean');
+    t.end();
+});
 
-exports['flag boolean value'] = function () {
+test('flag boolean value', function (t) {
     var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true'])
         .boolean(['t', 'verbose']).default('verbose', true).argv;
     
-    assert.eql(parse, {
+    t.same(parse, {
         verbose: false,
         t: true,
         _: ['moo'],
-        $0 : expresso
+        $0 : $0
     });
     
-    assert.eql(typeof parse.verbose, 'boolean');
-    assert.eql(typeof parse.t, 'boolean');
-};
+    t.same(typeof parse.verbose, 'boolean');
+    t.same(typeof parse.t, 'boolean');
+    t.end();
+});
 
-exports['flag boolean default false'] = function () {
+test('flag boolean default false', function (t) {
     var parse = optimist(['moo'])
         .boolean(['t', 'verbose'])
         .default('verbose', false)
         .default('t', false).argv;
     
-    assert.eql(parse, {
+    t.same(parse, {
         verbose: false,
         t: false,
         _: ['moo'],
-        $0 : expresso
+        $0 : $0
     });
     
-    assert.eql(typeof parse.verbose, 'boolean');
-    assert.eql(typeof parse.t, 'boolean');
-    
-};
+    t.same(typeof parse.verbose, 'boolean');
+    t.same(typeof parse.t, 'boolean');
+    t.end();
 
-exports['boolean groups'] = function () {
+});
+
+test('boolean groups', function (t) {
     var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ])
         .boolean(['x','y','z']).argv;
     
-    assert.eql(parse, {
+    t.same(parse, {
         x : true,
         y : false,
         z : true,
         _ : [ 'one', 'two', 'three' ],
-        $0 : expresso
+        $0 : $0
     });
     
-    assert.eql(typeof parse.x, 'boolean');
-    assert.eql(typeof parse.y, 'boolean');
-    assert.eql(typeof parse.z, 'boolean');
-};
+    t.same(typeof parse.x, 'boolean');
+    t.same(typeof parse.y, 'boolean');
+    t.same(typeof parse.z, 'boolean');
+    t.end();
+});
 
-exports.strings = function () {
+test('strings' , function (t) {
     var s = optimist([ '-s', '0001234' ]).string('s').argv.s;
-    assert.eql(s, '0001234');
-    assert.eql(typeof s, 'string');
+    t.same(s, '0001234');
+    t.same(typeof s, 'string');
     
     var x = optimist([ '-x', '56' ]).string('x').argv.x;
-    assert.eql(x, '56');
-    assert.eql(typeof x, 'string');
-};
+    t.same(x, '56');
+    t.same(typeof x, 'string');
+    t.end();
+});
 
-exports.stringArgs = function () {
+test('stringArgs', function (t) {
     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], '  ');
-};
+    t.same(s.length, 2);
+    t.same(typeof s[0], 'string');
+    t.same(s[0], '  ');
+    t.same(typeof s[1], 'string');
+    t.same(s[1], '  ');
+    t.end();
+});
 
-exports.slashBreak = function () {
-    assert.eql(
+test('slashBreak', function (t) {
+    t.same(
         optimist.parse([ '-I/foo/bar/baz' ]),
-        { I : '/foo/bar/baz', _ : [], $0 : expresso }
+        { I : '/foo/bar/baz', _ : [], $0 : $0 }
     );
-    assert.eql(
+    t.same(
         optimist.parse([ '-xyz/foo/bar/baz' ]),
-        { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : expresso }
+        { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : $0 }
     );
-};
+    t.end();
+});
 
-exports.alias = function () {
+test('alias', function (t) {
     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);
-};
+    t.equal(argv.zoom, 55);
+    t.equal(argv.z, argv.zoom);
+    t.equal(argv.f, 11);
+    t.end();
+});
 
-exports.multiAlias = function () {
+test('multiAlias', function (t) {
     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);
-};
+    t.equal(argv.zoom, 55);
+    t.equal(argv.z, argv.zoom);
+    t.equal(argv.z, argv.zm);
+    t.equal(argv.f, 11);
+    t.end();
+});
 
-exports['boolean default true'] = function () {
+test('boolean default true', function (t) {
     var argv = optimist.options({
         sometrue: {
             boolean: true,
@@ -289,10 +308,11 @@ exports['boolean default true'] = function () {
         }
     }).argv;
   
-    assert.equal(argv.sometrue, true);
-};
+    t.equal(argv.sometrue, true);
+    t.end();
+});
 
-exports['boolean default false'] = function () {
+test('boolean default false', function (t) {
     var argv = optimist.options({
         somefalse: {
             boolean: true,
@@ -300,5 +320,114 @@ exports['boolean default false'] = function () {
         }
     }).argv;
 
-    assert.equal(argv.somefalse, false);
-};
+    t.equal(argv.somefalse, false);
+    t.end();
+});
+
+test('nested dotted objects', function (t) {
+    var argv = optimist([
+        '--foo.bar', '3', '--foo.baz', '4',
+        '--foo.quux.quibble', '5', '--foo.quux.o_O',
+        '--beep.boop'
+    ]).argv;
+    
+    t.same(argv.foo, {
+        bar : 3,
+        baz : 4,
+        quux : {
+            quibble : 5,
+            o_O : true
+        },
+    });
+    t.same(argv.beep, { boop : true });
+    t.end();
+});
+
+test('boolean and alias with chainable api', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp',  'derp' ];
+    var opts = {
+        herp: { alias: 'h', boolean: true }
+    };
+    var aliasedArgv = optimist(aliased)
+        .boolean('herp')
+        .alias('h', 'herp')
+        .argv;
+    var propertyArgv = optimist(regular)
+        .boolean('herp')
+        .alias('h', 'herp')
+        .argv;
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ],
+        '$0': $0,
+    };
+
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+test('boolean and alias with options hash', function (t) {
+    var aliased = [ '-h', 'derp' ];
+    var regular = [ '--herp', 'derp' ];
+    var opts = {
+        herp: { alias: 'h', boolean: true }
+    };
+    var aliasedArgv = optimist(aliased)
+      .options(opts)
+      .argv;
+    var propertyArgv = optimist(regular).options(opts).argv;
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ 'derp' ],
+        '$0': $0,
+    };
+
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected);
+
+    t.end();
+});
+
+test('boolean and alias using explicit true', function (t) {
+    var aliased = [ '-h', 'true' ];
+    var regular = [ '--herp',  'true' ];
+    var opts = {
+        herp: { alias: 'h', boolean: true }
+    };
+    var aliasedArgv = optimist(aliased)
+        .boolean('h')
+        .alias('h', 'herp')
+        .argv;
+    var propertyArgv = optimist(regular)
+        .boolean('h')
+        .alias('h', 'herp')
+        .argv;
+    var expected = {
+        herp: true,
+        h: true,
+        '_': [ ],
+        '$0': $0,
+    };
+
+    t.same(aliasedArgv, expected);
+    t.same(propertyArgv, expected); 
+    t.end();
+});
+
+// regression, see https://github.com/substack/node-optimist/issues/71
+test('boolean and --x=true', function(t) {
+    var parsed = optimist(['--boool', '--other=true']).boolean('boool').argv;
+
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'true');
+
+    parsed = optimist(['--boool', '--other=false']).boolean('boool').argv;
+
+    t.same(parsed.boool, true);
+    t.same(parsed.other, 'false');
+    t.end();
+});

node_modules/optimist/test/usage.js

@@ -1,20 +1,20 @@
 var Hash = require('hashish');
 var optimist = require('../index');
-var assert = require('assert');
+var test = require('tap').test;
 
-exports.usageFail = function () {
+test('usageFail', function (t) {
     var r = checkUsage(function () {
         return optimist('-x 10 -z 20'.split(' '))
             .usage('Usage: $0 -x NUM -y NUM')
             .demand(['x','y'])
             .argv;
     });
-    assert.deepEqual(
+    t.same(
         r.result,
         { x : 10, z : 20, _ : [], $0 : './usage' }
     );
-    
-    assert.deepEqual(
+
+    t.same(
         r.errors.join('\n').split(/\n+/),
         [
             'Usage: ./usage -x NUM -y NUM',
@@ -24,26 +24,29 @@ exports.usageFail = function () {
             'Missing required arguments: y',
         ]
     );
-    assert.deepEqual(r.logs, []);
-    assert.ok(r.exit);
-};
+    t.same(r.logs, []);
+    t.ok(r.exit);
+    t.end();
+});
 
-exports.usagePass = function () {
+
+test('usagePass', function (t) {
     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, {
+    t.same(r, {
         result : { x : 10, y : 20, _ : [], $0 : './usage' },
         errors : [],
         logs : [],
         exit : false,
     });
-};
+    t.end();
+});
 
-exports.checkPass = function () {
+test('checkPass', function (t) {
     var r = checkUsage(function () {
         return optimist('-x 10 -y 20'.split(' '))
             .usage('Usage: $0 -x NUM -y NUM')
@@ -53,15 +56,16 @@ exports.checkPass = function () {
             })
             .argv;
     });
-    assert.deepEqual(r, {
+    t.same(r, {
         result : { x : 10, y : 20, _ : [], $0 : './usage' },
         errors : [],
         logs : [],
         exit : false,
     });
-};
+    t.end();
+});
 
-exports.checkFail = function () {
+test('checkFail', function (t) {
     var r = checkUsage(function () {
         return optimist('-x 10 -z 20'.split(' '))
             .usage('Usage: $0 -x NUM -y NUM')
@@ -71,110 +75,115 @@ exports.checkFail = function () {
             })
             .argv;
     });
-    
-    assert.deepEqual(
+
+    t.same(
         r.result,
         { x : 10, z : 20, _ : [], $0 : './usage' }
     );
-    
-    assert.deepEqual(
+
+    t.same(
         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 () {
+    t.same(r.logs, []);
+    t.ok(r.exit);
+    t.end();
+});
+
+test('checkCondPass', function (t) {
     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, {
+    t.same(r, {
         result : { x : 10, y : 20, _ : [], $0 : './usage' },
         errors : [],
         logs : [],
         exit : false,
     });
-};
+    t.end();
+});
 
-exports.checkCondFail = function () {
+test('checkCondFail', function (t) {
     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(
+
+    t.same(
         r.result,
         { x : 10, z : 20, _ : [], $0 : './usage' }
     );
-    
-    assert.deepEqual(
+
+    t.same(
         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 () {
+    t.same(r.logs, []);
+    t.ok(r.exit);
+    t.end();
+});
+
+test('countPass', function (t) {
     var r = checkUsage(function () {
         return optimist('1 2 3 --moo'.split(' '))
             .usage('Usage: $0 [x] [y] [z] {OPTIONS}')
             .demand(3)
             .argv;
     });
-    assert.deepEqual(r, {
+    t.same(r, {
         result : { _ : [ '1', '2', '3' ], moo : true, $0 : './usage' },
         errors : [],
         logs : [],
         exit : false,
     });
-};
+    t.end();
+});
 
-exports.countFail = function () {
+test('countFail', function (t) {
     var r = checkUsage(function () {
         return optimist('1 2 --moo'.split(' '))
             .usage('Usage: $0 [x] [y] [z] {OPTIONS}')
             .demand(3)
             .argv;
     });
-    assert.deepEqual(
+    t.same(
         r.result,
         { _ : [ '1', '2' ], moo : true, $0 : './usage' }
     );
-    
-    assert.deepEqual(
+
+    t.same(
         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 () {
+    t.same(r.logs, []);
+    t.ok(r.exit);
+    t.end();
+});
+
+test('defaultSingles', function (t) {
     var r = checkUsage(function () {
         return optimist('--foo 50 --baz 70 --powsy'.split(' '))
             .default('foo', 5)
@@ -183,7 +192,7 @@ exports.defaultSingles = function () {
             .argv
         ;
     });
-    assert.eql(r.result, {
+    t.same(r.result, {
         foo : '50',
         bar : 6,
         baz : '70',
@@ -191,62 +200,89 @@ exports.defaultSingles = function () {
         _ : [],
         $0 : './usage',
     });
-};
+    t.end();
+});
 
-exports.defaultHash = function () {
+test('defaultAliases', function (t) {
+    var r = checkUsage(function () {
+        return optimist('')
+            .alias('f', 'foo')
+            .default('f', 5)
+            .argv
+        ;
+    });
+    t.same(r.result, {
+        f : '5',
+        foo : '5',
+        _ : [],
+        $0 : './usage',
+    });
+    t.end();
+});
+
+test('defaultHash', function (t) {
     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,
+    t.same(r.result, {
         _ : [],
         $0 : './usage',
+        foo : 50,
+        baz : 70,
+        bar : 20,
+        quux : 30,
     });
-};
+    t.end();
+});
 
-exports.rebase = function () {
-    assert.equal(
+test('rebase', function (t) {
+    t.equal(
         optimist.rebase('/home/substack', '/home/substack/foo/bar/baz'),
         './foo/bar/baz'
     );
-    assert.equal(
+    t.equal(
         optimist.rebase('/home/substack/foo/bar/baz', '/home/substack'),
         '../../..'
     );
-    assert.equal(
+    t.equal(
         optimist.rebase('/home/substack/foo', '/home/substack/pow/zoom.txt'),
         '../pow/zoom.txt'
     );
-};
+    t.end();
+});
 
 function checkUsage (f) {
-    var _process = process;
-    process = Hash.copy(process);
+
     var exit = false;
-    process.exit = function () { exit = true };
+
+    process._exit = process.exit;
+    process._env = process.env;
+    process._argv = process.argv;
+
+    process.exit = function (t) { 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;
+
+    process.exit = process._exit;
+    process.env = process._env;
+    process.argv = process._argv;
+
     console.error = console._error;
     console.log = console._log;
-    
+
     return {
         errors : errors,
         logs : logs,