| var optimist = require('../index'); |
| var path = require('path'); |
| var test = require('tap').test; |
| |
| var $0 = 'node ./' + path.relative(process.cwd(), __filename); |
| |
| test('short boolean', function (t) { |
| var parse = optimist.parse([ '-b' ]); |
| t.same(parse, { b : true, _ : [], $0 : $0 }); |
| t.same(typeof parse.b, 'boolean'); |
| t.end(); |
| }); |
| |
| test('long boolean', function (t) { |
| t.same( |
| optimist.parse([ '--bool' ]), |
| { bool : true, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('bare', function (t) { |
| t.same( |
| optimist.parse([ 'foo', 'bar', 'baz' ]), |
| { _ : [ 'foo', 'bar', 'baz' ], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('short group', function (t) { |
| t.same( |
| optimist.parse([ '-cats' ]), |
| { c : true, a : true, t : true, s : true, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('short group next', function (t) { |
| t.same( |
| optimist.parse([ '-cats', 'meow' ]), |
| { c : true, a : true, t : true, s : 'meow', _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('short capture', function (t) { |
| t.same( |
| optimist.parse([ '-h', 'localhost' ]), |
| { h : 'localhost', _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('short captures', function (t) { |
| t.same( |
| optimist.parse([ '-h', 'localhost', '-p', '555' ]), |
| { h : 'localhost', p : 555, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('long capture sp', function (t) { |
| t.same( |
| optimist.parse([ '--pow', 'xixxle' ]), |
| { pow : 'xixxle', _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('long capture eq', function (t) { |
| t.same( |
| optimist.parse([ '--pow=xixxle' ]), |
| { pow : 'xixxle', _ : [], $0 : $0 } |
| ); |
| t.end() |
| }); |
| |
| test('long captures sp', function (t) { |
| t.same( |
| optimist.parse([ '--host', 'localhost', '--port', '555' ]), |
| { host : 'localhost', port : 555, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('long captures eq', function (t) { |
| t.same( |
| optimist.parse([ '--host=localhost', '--port=555' ]), |
| { host : 'localhost', port : 555, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| 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 : $0, |
| } |
| ); |
| t.end(); |
| }); |
| |
| 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 : $0, |
| } |
| ); |
| t.end(); |
| }); |
| |
| test('no', function (t) { |
| t.same( |
| optimist.parse([ '--no-moo' ]), |
| { moo : false, _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('multi', function (t) { |
| t.same( |
| optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]), |
| { v : ['a','b','c'], _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('comprehensive', function (t) { |
| t.same( |
| 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 : $0 |
| } |
| ); |
| t.end(); |
| }); |
| |
| test('nums', function (t) { |
| var argv = optimist.parse([ |
| '-x', '1234', |
| '-y', '5.67', |
| '-z', '1e7', |
| '-w', '10f', |
| '--hex', '0xdeadbeef', |
| '789', |
| ]); |
| t.same(argv, { |
| x : 1234, |
| y : 5.67, |
| z : 1e7, |
| w : '10f', |
| hex : 0xdeadbeef, |
| _ : [ 789 ], |
| $0 : $0 |
| }); |
| 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(); |
| }); |
| |
| test('flag boolean', function (t) { |
| var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv; |
| t.same(parse, { t : true, _ : [ 'moo' ], $0 : $0 }); |
| t.same(typeof parse.t, 'boolean'); |
| t.end(); |
| }); |
| |
| test('flag boolean value', function (t) { |
| var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true']) |
| .boolean(['t', 'verbose']).default('verbose', true).argv; |
| |
| t.same(parse, { |
| verbose: false, |
| t: true, |
| _: ['moo'], |
| $0 : $0 |
| }); |
| |
| t.same(typeof parse.verbose, 'boolean'); |
| t.same(typeof parse.t, 'boolean'); |
| t.end(); |
| }); |
| |
| test('flag boolean default false', function (t) { |
| var parse = optimist(['moo']) |
| .boolean(['t', 'verbose']) |
| .default('verbose', false) |
| .default('t', false).argv; |
| |
| t.same(parse, { |
| verbose: false, |
| t: false, |
| _: ['moo'], |
| $0 : $0 |
| }); |
| |
| t.same(typeof parse.verbose, 'boolean'); |
| t.same(typeof parse.t, 'boolean'); |
| t.end(); |
| |
| }); |
| |
| test('boolean groups', function (t) { |
| var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ]) |
| .boolean(['x','y','z']).argv; |
| |
| t.same(parse, { |
| x : true, |
| y : false, |
| z : true, |
| _ : [ 'one', 'two', 'three' ], |
| $0 : $0 |
| }); |
| |
| t.same(typeof parse.x, 'boolean'); |
| t.same(typeof parse.y, 'boolean'); |
| t.same(typeof parse.z, 'boolean'); |
| t.end(); |
| }); |
| |
| test('newlines in params' , function (t) { |
| var args = optimist.parse([ '-s', "X\nX" ]) |
| t.same(args, { _ : [], s : "X\nX", $0 : $0 }); |
| |
| // reproduce in bash: |
| // VALUE="new |
| // line" |
| // node program.js --s="$VALUE" |
| args = optimist.parse([ "--s=X\nX" ]) |
| t.same(args, { _ : [], s : "X\nX", $0 : $0 }); |
| t.end(); |
| }); |
| |
| test('strings' , function (t) { |
| var s = optimist([ '-s', '0001234' ]).string('s').argv.s; |
| t.same(s, '0001234'); |
| t.same(typeof s, 'string'); |
| |
| var x = optimist([ '-x', '56' ]).string('x').argv.x; |
| t.same(x, '56'); |
| t.same(typeof x, 'string'); |
| t.end(); |
| }); |
| |
| test('stringArgs', function (t) { |
| var s = optimist([ ' ', ' ' ]).string('_').argv._; |
| 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(); |
| }); |
| |
| test('slashBreak', function (t) { |
| t.same( |
| optimist.parse([ '-I/foo/bar/baz' ]), |
| { I : '/foo/bar/baz', _ : [], $0 : $0 } |
| ); |
| t.same( |
| optimist.parse([ '-xyz/foo/bar/baz' ]), |
| { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : $0 } |
| ); |
| t.end(); |
| }); |
| |
| test('alias', function (t) { |
| var argv = optimist([ '-f', '11', '--zoom', '55' ]) |
| .alias('z', 'zoom') |
| .argv |
| ; |
| t.equal(argv.zoom, 55); |
| t.equal(argv.z, argv.zoom); |
| t.equal(argv.f, 11); |
| t.end(); |
| }); |
| |
| test('multiAlias', function (t) { |
| var argv = optimist([ '-f', '11', '--zoom', '55' ]) |
| .alias('z', [ 'zm', 'zoom' ]) |
| .argv |
| ; |
| t.equal(argv.zoom, 55); |
| t.equal(argv.z, argv.zoom); |
| t.equal(argv.z, argv.zm); |
| t.equal(argv.f, 11); |
| t.end(); |
| }); |
| |
| test('boolean default true', function (t) { |
| var argv = optimist.options({ |
| sometrue: { |
| boolean: true, |
| default: true |
| } |
| }).argv; |
| |
| t.equal(argv.sometrue, true); |
| t.end(); |
| }); |
| |
| test('boolean default false', function (t) { |
| var argv = optimist.options({ |
| somefalse: { |
| boolean: true, |
| default: false |
| } |
| }).argv; |
| |
| 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(); |
| }); |