|
'use strict'; |
|
|
|
var parse = require('../'); |
|
var test = require('tape'); |
|
|
|
test('parse args', function (t) { |
|
t.deepEqual( |
|
parse(['--no-moo']), |
|
{ moo: false, _: [] }, |
|
'no' |
|
); |
|
t.deepEqual( |
|
parse(['-v', 'a', '-v', 'b', '-v', 'c']), |
|
{ v: ['a', 'b', 'c'], _: [] }, |
|
'multi' |
|
); |
|
t.end(); |
|
}); |
|
|
|
test('comprehensive', function (t) { |
|
t.deepEqual( |
|
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'], |
|
} |
|
); |
|
t.end(); |
|
}); |
|
|
|
test('flag boolean', function (t) { |
|
var argv = parse(['-t', 'moo'], { boolean: 't' }); |
|
t.deepEqual(argv, { t: true, _: ['moo'] }); |
|
t.deepEqual(typeof argv.t, 'boolean'); |
|
t.end(); |
|
}); |
|
|
|
test('flag boolean value', function (t) { |
|
var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], { |
|
boolean: ['t', 'verbose'], |
|
default: { verbose: true }, |
|
}); |
|
|
|
t.deepEqual(argv, { |
|
verbose: false, |
|
t: true, |
|
_: ['moo'], |
|
}); |
|
|
|
t.deepEqual(typeof argv.verbose, 'boolean'); |
|
t.deepEqual(typeof argv.t, 'boolean'); |
|
t.end(); |
|
}); |
|
|
|
test('newlines in params', function (t) { |
|
var args = parse(['-s', 'X\nX']); |
|
t.deepEqual(args, { _: [], s: 'X\nX' }); |
|
|
|
|
|
|
|
|
|
|
|
args = parse(['--s=X\nX']); |
|
t.deepEqual(args, { _: [], s: 'X\nX' }); |
|
t.end(); |
|
}); |
|
|
|
test('strings', function (t) { |
|
var s = parse(['-s', '0001234'], { string: 's' }).s; |
|
t.equal(s, '0001234'); |
|
t.equal(typeof s, 'string'); |
|
|
|
var x = parse(['-x', '56'], { string: 'x' }).x; |
|
t.equal(x, '56'); |
|
t.equal(typeof x, 'string'); |
|
t.end(); |
|
}); |
|
|
|
test('stringArgs', function (t) { |
|
var s = parse([' ', ' '], { string: '_' })._; |
|
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('empty strings', function (t) { |
|
var s = parse(['-s'], { string: 's' }).s; |
|
t.equal(s, ''); |
|
t.equal(typeof s, 'string'); |
|
|
|
var str = parse(['--str'], { string: 'str' }).str; |
|
t.equal(str, ''); |
|
t.equal(typeof str, 'string'); |
|
|
|
var letters = parse(['-art'], { |
|
string: ['a', 't'], |
|
}); |
|
|
|
t.equal(letters.a, ''); |
|
t.equal(letters.r, true); |
|
t.equal(letters.t, ''); |
|
|
|
t.end(); |
|
}); |
|
|
|
test('string and alias', function (t) { |
|
var x = parse(['--str', '000123'], { |
|
string: 's', |
|
alias: { s: 'str' }, |
|
}); |
|
|
|
t.equal(x.str, '000123'); |
|
t.equal(typeof x.str, 'string'); |
|
t.equal(x.s, '000123'); |
|
t.equal(typeof x.s, 'string'); |
|
|
|
var y = parse(['-s', '000123'], { |
|
string: 'str', |
|
alias: { str: 's' }, |
|
}); |
|
|
|
t.equal(y.str, '000123'); |
|
t.equal(typeof y.str, 'string'); |
|
t.equal(y.s, '000123'); |
|
t.equal(typeof y.s, 'string'); |
|
|
|
var z = parse(['-s123'], { |
|
alias: { str: ['s', 'S'] }, |
|
string: ['str'], |
|
}); |
|
|
|
t.deepEqual( |
|
z, |
|
{ _: [], s: '123', S: '123', str: '123' }, |
|
'opt.string works with multiple aliases' |
|
); |
|
t.end(); |
|
}); |
|
|
|
test('slashBreak', function (t) { |
|
t.same( |
|
parse(['-I/foo/bar/baz']), |
|
{ I: '/foo/bar/baz', _: [] } |
|
); |
|
t.same( |
|
parse(['-xyz/foo/bar/baz']), |
|
{ x: true, y: true, z: '/foo/bar/baz', _: [] } |
|
); |
|
t.end(); |
|
}); |
|
|
|
test('alias', function (t) { |
|
var argv = parse(['-f', '11', '--zoom', '55'], { |
|
alias: { z: 'zoom' }, |
|
}); |
|
t.equal(argv.zoom, 55); |
|
t.equal(argv.z, argv.zoom); |
|
t.equal(argv.f, 11); |
|
t.end(); |
|
}); |
|
|
|
test('multiAlias', function (t) { |
|
var argv = parse(['-f', '11', '--zoom', '55'], { |
|
alias: { z: ['zm', 'zoom'] }, |
|
}); |
|
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('nested dotted objects', function (t) { |
|
var argv = parse([ |
|
'--foo.bar', '3', '--foo.baz', '4', |
|
'--foo.quux.quibble', '5', '--foo.quux.o_O', |
|
'--beep.boop', |
|
]); |
|
|
|
t.same(argv.foo, { |
|
bar: 3, |
|
baz: 4, |
|
quux: { |
|
quibble: 5, |
|
o_O: true, |
|
}, |
|
}); |
|
t.same(argv.beep, { boop: true }); |
|
t.end(); |
|
}); |
|
|