1var optimist = require('../index');
  2var path = require('path');
  3var test = require('tap').test;
  4
  5var $0 = 'node ./' + path.relative(process.cwd(), __filename);
  6
  7test('short boolean', function (t) {
  8    var parse = optimist.parse([ '-b' ]);
  9    t.same(parse, { b : true, _ : [], $0 : $0 });
 10    t.same(typeof parse.b, 'boolean');
 11    t.end();
 12});
 13
 14test('long boolean', function (t) {
 15    t.same(
 16        optimist.parse([ '--bool' ]),
 17        { bool : true, _ : [], $0 : $0 }
 18    );
 19    t.end();
 20});
 21    
 22test('bare', function (t) {
 23    t.same(
 24        optimist.parse([ 'foo', 'bar', 'baz' ]),
 25        { _ : [ 'foo', 'bar', 'baz' ], $0 : $0 }
 26    );
 27    t.end();
 28});
 29
 30test('short group', function (t) {
 31    t.same(
 32        optimist.parse([ '-cats' ]),
 33        { c : true, a : true, t : true, s : true, _ : [], $0 : $0 }
 34    );
 35    t.end();
 36});
 37
 38test('short group next', function (t) {
 39    t.same(
 40        optimist.parse([ '-cats', 'meow' ]),
 41        { c : true, a : true, t : true, s : 'meow', _ : [], $0 : $0 }
 42    );
 43    t.end();
 44});
 45 
 46test('short capture', function (t) {
 47    t.same(
 48        optimist.parse([ '-h', 'localhost' ]),
 49        { h : 'localhost', _ : [], $0 : $0 }
 50    );
 51    t.end();
 52});
 53
 54test('short captures', function (t) {
 55    t.same(
 56        optimist.parse([ '-h', 'localhost', '-p', '555' ]),
 57        { h : 'localhost', p : 555, _ : [], $0 : $0 }
 58    );
 59    t.end();
 60});
 61
 62test('long capture sp', function (t) {
 63    t.same(
 64        optimist.parse([ '--pow', 'xixxle' ]),
 65        { pow : 'xixxle', _ : [], $0 : $0 }
 66    );
 67    t.end();
 68});
 69
 70test('long capture eq', function (t) {
 71    t.same(
 72        optimist.parse([ '--pow=xixxle' ]),
 73        { pow : 'xixxle', _ : [], $0 : $0 }
 74    );
 75    t.end()
 76});
 77
 78test('long captures sp', function (t) {
 79    t.same(
 80        optimist.parse([ '--host', 'localhost', '--port', '555' ]),
 81        { host : 'localhost', port : 555, _ : [], $0 : $0 }
 82    );
 83    t.end();
 84});
 85
 86test('long captures eq', function (t) {
 87    t.same(
 88        optimist.parse([ '--host=localhost', '--port=555' ]),
 89        { host : 'localhost', port : 555, _ : [], $0 : $0 }
 90    );
 91    t.end();
 92});
 93
 94test('mixed short bool and capture', function (t) {
 95    t.same(
 96        optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
 97        {
 98            f : true, p : 555, h : 'localhost',
 99            _ : [ 'script.js' ], $0 : $0,
100        }
101    );
102    t.end();
103});
104 
105test('short and long', function (t) {
106    t.same(
107        optimist.parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
108        {
109            f : true, p : 555, h : 'localhost',
110            _ : [ 'script.js' ], $0 : $0,
111        }
112    );
113    t.end();
114});
115
116test('no', function (t) {
117    t.same(
118        optimist.parse([ '--no-moo' ]),
119        { moo : false, _ : [], $0 : $0 }
120    );
121    t.end();
122});
123 
124test('multi', function (t) {
125    t.same(
126        optimist.parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
127        { v : ['a','b','c'], _ : [], $0 : $0 }
128    );
129    t.end();
130});
131 
132test('comprehensive', function (t) {
133    t.same(
134        optimist.parse([
135            '--name=meowmers', 'bare', '-cats', 'woo',
136            '-h', 'awesome', '--multi=quux',
137            '--key', 'value',
138            '-b', '--bool', '--no-meep', '--multi=baz',
139            '--', '--not-a-flag', 'eek'
140        ]),
141        {
142            c : true,
143            a : true,
144            t : true,
145            s : 'woo',
146            h : 'awesome',
147            b : true,
148            bool : true,
149            key : 'value',
150            multi : [ 'quux', 'baz' ],
151            meep : false,
152            name : 'meowmers',
153            _ : [ 'bare', '--not-a-flag', 'eek' ],
154            $0 : $0
155        }
156    );
157    t.end();
158});
159
160test('nums', function (t) {
161    var argv = optimist.parse([
162        '-x', '1234',
163        '-y', '5.67',
164        '-z', '1e7',
165        '-w', '10f',
166        '--hex', '0xdeadbeef',
167        '789',
168    ]);
169    t.same(argv, {
170        x : 1234,
171        y : 5.67,
172        z : 1e7,
173        w : '10f',
174        hex : 0xdeadbeef,
175        _ : [ 789 ],
176        $0 : $0
177    });
178    t.same(typeof argv.x, 'number');
179    t.same(typeof argv.y, 'number');
180    t.same(typeof argv.z, 'number');
181    t.same(typeof argv.w, 'string');
182    t.same(typeof argv.hex, 'number');
183    t.same(typeof argv._[0], 'number');
184    t.end();
185});
186
187test('flag boolean', function (t) {
188    var parse = optimist([ '-t', 'moo' ]).boolean(['t']).argv;
189    t.same(parse, { t : true, _ : [ 'moo' ], $0 : $0 });
190    t.same(typeof parse.t, 'boolean');
191    t.end();
192});
193
194test('flag boolean value', function (t) {
195    var parse = optimist(['--verbose', 'false', 'moo', '-t', 'true'])
196        .boolean(['t', 'verbose']).default('verbose', true).argv;
197    
198    t.same(parse, {
199        verbose: false,
200        t: true,
201        _: ['moo'],
202        $0 : $0
203    });
204    
205    t.same(typeof parse.verbose, 'boolean');
206    t.same(typeof parse.t, 'boolean');
207    t.end();
208});
209
210test('flag boolean default false', function (t) {
211    var parse = optimist(['moo'])
212        .boolean(['t', 'verbose'])
213        .default('verbose', false)
214        .default('t', false).argv;
215    
216    t.same(parse, {
217        verbose: false,
218        t: false,
219        _: ['moo'],
220        $0 : $0
221    });
222    
223    t.same(typeof parse.verbose, 'boolean');
224    t.same(typeof parse.t, 'boolean');
225    t.end();
226
227});
228
229test('boolean groups', function (t) {
230    var parse = optimist([ '-x', '-z', 'one', 'two', 'three' ])
231        .boolean(['x','y','z']).argv;
232    
233    t.same(parse, {
234        x : true,
235        y : false,
236        z : true,
237        _ : [ 'one', 'two', 'three' ],
238        $0 : $0
239    });
240    
241    t.same(typeof parse.x, 'boolean');
242    t.same(typeof parse.y, 'boolean');
243    t.same(typeof parse.z, 'boolean');
244    t.end();
245});
246
247test('newlines in params' , function (t) {
248    var args = optimist.parse([ '-s', "X\nX" ])
249    t.same(args, { _ : [], s : "X\nX", $0 : $0 });
250
251    // reproduce in bash:
252    // VALUE="new
253    // line"
254    // node program.js --s="$VALUE"
255    args = optimist.parse([ "--s=X\nX" ])
256    t.same(args, { _ : [], s : "X\nX", $0 : $0 });
257    t.end();
258});
259
260test('strings' , function (t) {
261    var s = optimist([ '-s', '0001234' ]).string('s').argv.s;
262    t.same(s, '0001234');
263    t.same(typeof s, 'string');
264    
265    var x = optimist([ '-x', '56' ]).string('x').argv.x;
266    t.same(x, '56');
267    t.same(typeof x, 'string');
268    t.end();
269});
270
271test('stringArgs', function (t) {
272    var s = optimist([ '  ', '  ' ]).string('_').argv._;
273    t.same(s.length, 2);
274    t.same(typeof s[0], 'string');
275    t.same(s[0], '  ');
276    t.same(typeof s[1], 'string');
277    t.same(s[1], '  ');
278    t.end();
279});
280
281test('slashBreak', function (t) {
282    t.same(
283        optimist.parse([ '-I/foo/bar/baz' ]),
284        { I : '/foo/bar/baz', _ : [], $0 : $0 }
285    );
286    t.same(
287        optimist.parse([ '-xyz/foo/bar/baz' ]),
288        { x : true, y : true, z : '/foo/bar/baz', _ : [], $0 : $0 }
289    );
290    t.end();
291});
292
293test('alias', function (t) {
294    var argv = optimist([ '-f', '11', '--zoom', '55' ])
295        .alias('z', 'zoom')
296        .argv
297    ;
298    t.equal(argv.zoom, 55);
299    t.equal(argv.z, argv.zoom);
300    t.equal(argv.f, 11);
301    t.end();
302});
303
304test('multiAlias', function (t) {
305    var argv = optimist([ '-f', '11', '--zoom', '55' ])
306        .alias('z', [ 'zm', 'zoom' ])
307        .argv
308    ;
309    t.equal(argv.zoom, 55);
310    t.equal(argv.z, argv.zoom);
311    t.equal(argv.z, argv.zm);
312    t.equal(argv.f, 11);
313    t.end();
314});
315
316test('boolean default true', function (t) {
317    var argv = optimist.options({
318        sometrue: {
319            boolean: true,
320            default: true
321        }
322    }).argv;
323  
324    t.equal(argv.sometrue, true);
325    t.end();
326});
327
328test('boolean default false', function (t) {
329    var argv = optimist.options({
330        somefalse: {
331            boolean: true,
332            default: false
333        }
334    }).argv;
335
336    t.equal(argv.somefalse, false);
337    t.end();
338});
339
340test('nested dotted objects', function (t) {
341    var argv = optimist([
342        '--foo.bar', '3', '--foo.baz', '4',
343        '--foo.quux.quibble', '5', '--foo.quux.o_O',
344        '--beep.boop'
345    ]).argv;
346    
347    t.same(argv.foo, {
348        bar : 3,
349        baz : 4,
350        quux : {
351            quibble : 5,
352            o_O : true
353        },
354    });
355    t.same(argv.beep, { boop : true });
356    t.end();
357});
358
359test('boolean and alias with chainable api', function (t) {
360    var aliased = [ '-h', 'derp' ];
361    var regular = [ '--herp',  'derp' ];
362    var opts = {
363        herp: { alias: 'h', boolean: true }
364    };
365    var aliasedArgv = optimist(aliased)
366        .boolean('herp')
367        .alias('h', 'herp')
368        .argv;
369    var propertyArgv = optimist(regular)
370        .boolean('herp')
371        .alias('h', 'herp')
372        .argv;
373    var expected = {
374        herp: true,
375        h: true,
376        '_': [ 'derp' ],
377        '$0': $0,
378    };
379
380    t.same(aliasedArgv, expected);
381    t.same(propertyArgv, expected); 
382    t.end();
383});
384
385test('boolean and alias with options hash', function (t) {
386    var aliased = [ '-h', 'derp' ];
387    var regular = [ '--herp', 'derp' ];
388    var opts = {
389        herp: { alias: 'h', boolean: true }
390    };
391    var aliasedArgv = optimist(aliased)
392      .options(opts)
393      .argv;
394    var propertyArgv = optimist(regular).options(opts).argv;
395    var expected = {
396        herp: true,
397        h: true,
398        '_': [ 'derp' ],
399        '$0': $0,
400    };
401
402    t.same(aliasedArgv, expected);
403    t.same(propertyArgv, expected);
404
405    t.end();
406});
407
408test('boolean and alias using explicit true', function (t) {
409    var aliased = [ '-h', 'true' ];
410    var regular = [ '--herp',  'true' ];
411    var opts = {
412        herp: { alias: 'h', boolean: true }
413    };
414    var aliasedArgv = optimist(aliased)
415        .boolean('h')
416        .alias('h', 'herp')
417        .argv;
418    var propertyArgv = optimist(regular)
419        .boolean('h')
420        .alias('h', 'herp')
421        .argv;
422    var expected = {
423        herp: true,
424        h: true,
425        '_': [ ],
426        '$0': $0,
427    };
428
429    t.same(aliasedArgv, expected);
430    t.same(propertyArgv, expected); 
431    t.end();
432});
433
434// regression, see https://github.com/substack/node-optimist/issues/71
435test('boolean and --x=true', function(t) {
436    var parsed = optimist(['--boool', '--other=true']).boolean('boool').argv;
437
438    t.same(parsed.boool, true);
439    t.same(parsed.other, 'true');
440
441    parsed = optimist(['--boool', '--other=false']).boolean('boool').argv;
442
443    t.same(parsed.boool, true);
444    t.same(parsed.other, 'false');
445    t.end();
446});