www.aleph1.co.uk Git - yaffs-website/blob - node_modules/mkdirp/node_modules/minimist/test/parse.js

   1 var parse = require('../');
   2 var test = require('tape');
   3
   4 test('parse args', function (t) {
   5     t.deepEqual(
   6         parse([ '--no-moo' ]),
   7         { moo : false, _ : [] },
   8         'no'
   9     );
  10     t.deepEqual(
  11         parse([ '-v', 'a', '-v', 'b', '-v', 'c' ]),
  12         { v : ['a','b','c'], _ : [] },
  13         'multi'
  14     );
  15     t.end();
  16 });
  17
  18 test('comprehensive', function (t) {
  19     t.deepEqual(
  20         parse([
  21             '--name=meowmers', 'bare', '-cats', 'woo',
  22             '-h', 'awesome', '--multi=quux',
  23             '--key', 'value',
  24             '-b', '--bool', '--no-meep', '--multi=baz',
  25             '--', '--not-a-flag', 'eek'
  26         ]),
  27         {
  28             c : true,
  29             a : true,
  30             t : true,
  31             s : 'woo',
  32             h : 'awesome',
  33             b : true,
  34             bool : true,
  35             key : 'value',
  36             multi : [ 'quux', 'baz' ],
  37             meep : false,
  38             name : 'meowmers',
  39             _ : [ 'bare', '--not-a-flag', 'eek' ]
  40         }
  41     );
  42     t.end();
  43 });
  44
  45 test('nums', function (t) {
  46     var argv = parse([
  47         '-x', '1234',
  48         '-y', '5.67',
  49         '-z', '1e7',
  50         '-w', '10f',
  51         '--hex', '0xdeadbeef',
  52         '789'
  53     ]);
  54     t.deepEqual(argv, {
  55         x : 1234,
  56         y : 5.67,
  57         z : 1e7,
  58         w : '10f',
  59         hex : 0xdeadbeef,
  60         _ : [ 789 ]
  61     });
  62     t.deepEqual(typeof argv.x, 'number');
  63     t.deepEqual(typeof argv.y, 'number');
  64     t.deepEqual(typeof argv.z, 'number');
  65     t.deepEqual(typeof argv.w, 'string');
  66     t.deepEqual(typeof argv.hex, 'number');
  67     t.deepEqual(typeof argv._[0], 'number');
  68     t.end();
  69 });
  70
  71 test('flag boolean', function (t) {
  72     var argv = parse([ '-t', 'moo' ], { boolean: 't' });
  73     t.deepEqual(argv, { t : true, _ : [ 'moo' ] });
  74     t.deepEqual(typeof argv.t, 'boolean');
  75     t.end();
  76 });
  77
  78 test('flag boolean value', function (t) {
  79     var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], {
  80         boolean: [ 't', 'verbose' ],
  81         default: { verbose: true }
  82     });
  83
  84     t.deepEqual(argv, {
  85         verbose: false,
  86         t: true,
  87         _: ['moo']
  88     });
  89
  90     t.deepEqual(typeof argv.verbose, 'boolean');
  91     t.deepEqual(typeof argv.t, 'boolean');
  92     t.end();
  93 });
  94
  95 test('flag boolean default false', function (t) {
  96     var argv = parse(['moo'], {
  97         boolean: ['t', 'verbose'],
  98         default: { verbose: false, t: false }
  99     });
 100
 101     t.deepEqual(argv, {
 102         verbose: false,
 103         t: false,
 104         _: ['moo']
 105     });
 106
 107     t.deepEqual(typeof argv.verbose, 'boolean');
 108     t.deepEqual(typeof argv.t, 'boolean');
 109     t.end();
 110
 111 });
 112
 113 test('boolean groups', function (t) {
 114     var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], {
 115         boolean: ['x','y','z']
 116     });
 117
 118     t.deepEqual(argv, {
 119         x : true,
 120         y : false,
 121         z : true,
 122         _ : [ 'one', 'two', 'three' ]
 123     });
 124
 125     t.deepEqual(typeof argv.x, 'boolean');
 126     t.deepEqual(typeof argv.y, 'boolean');
 127     t.deepEqual(typeof argv.z, 'boolean');
 128     t.end();
 129 });
 130
 131 test('newlines in params' , function (t) {
 132     var args = parse([ '-s', "X\nX" ])
 133     t.deepEqual(args, { _ : [], s : "X\nX" });
 134
 135     // reproduce in bash:
 136     // VALUE="new
 137     // line"
 138     // node program.js --s="$VALUE"
 139     args = parse([ "--s=X\nX" ])
 140     t.deepEqual(args, { _ : [], s : "X\nX" });
 141     t.end();
 142 });
 143
 144 test('strings' , function (t) {
 145     var s = parse([ '-s', '0001234' ], { string: 's' }).s;
 146     t.equal(s, '0001234');
 147     t.equal(typeof s, 'string');
 148
 149     var x = parse([ '-x', '56' ], { string: 'x' }).x;
 150     t.equal(x, '56');
 151     t.equal(typeof x, 'string');
 152     t.end();
 153 });
 154
 155 test('stringArgs', function (t) {
 156     var s = parse([ '  ', '  ' ], { string: '_' })._;
 157     t.same(s.length, 2);
 158     t.same(typeof s[0], 'string');
 159     t.same(s[0], '  ');
 160     t.same(typeof s[1], 'string');
 161     t.same(s[1], '  ');
 162     t.end();
 163 });
 164
 165 test('empty strings', function(t) {
 166     var s = parse([ '-s' ], { string: 's' }).s;
 167     t.equal(s, '');
 168     t.equal(typeof s, 'string');
 169
 170     var str = parse([ '--str' ], { string: 'str' }).str;
 171     t.equal(str, '');
 172     t.equal(typeof str, 'string');
 173
 174     var letters = parse([ '-art' ], {
 175         string: [ 'a', 't' ]
 176     });
 177
 178     t.equal(letters.a, '');
 179     t.equal(letters.r, true);
 180     t.equal(letters.t, '');
 181
 182     t.end();
 183 });
 184
 185
 186 test('slashBreak', function (t) {
 187     t.same(
 188         parse([ '-I/foo/bar/baz' ]),
 189         { I : '/foo/bar/baz', _ : [] }
 190     );
 191     t.same(
 192         parse([ '-xyz/foo/bar/baz' ]),
 193         { x : true, y : true, z : '/foo/bar/baz', _ : [] }
 194     );
 195     t.end();
 196 });
 197
 198 test('alias', function (t) {
 199     var argv = parse([ '-f', '11', '--zoom', '55' ], {
 200         alias: { z: 'zoom' }
 201     });
 202     t.equal(argv.zoom, 55);
 203     t.equal(argv.z, argv.zoom);
 204     t.equal(argv.f, 11);
 205     t.end();
 206 });
 207
 208 test('multiAlias', function (t) {
 209     var argv = parse([ '-f', '11', '--zoom', '55' ], {
 210         alias: { z: [ 'zm', 'zoom' ] }
 211     });
 212     t.equal(argv.zoom, 55);
 213     t.equal(argv.z, argv.zoom);
 214     t.equal(argv.z, argv.zm);
 215     t.equal(argv.f, 11);
 216     t.end();
 217 });
 218
 219 test('nested dotted objects', function (t) {
 220     var argv = parse([
 221         '--foo.bar', '3', '--foo.baz', '4',
 222         '--foo.quux.quibble', '5', '--foo.quux.o_O',
 223         '--beep.boop'
 224     ]);
 225
 226     t.same(argv.foo, {
 227         bar : 3,
 228         baz : 4,
 229         quux : {
 230             quibble : 5,
 231             o_O : true
 232         }
 233     });
 234     t.same(argv.beep, { boop : true });
 235     t.end();
 236 });
 237
 238 test('boolean and alias with chainable api', function (t) {
 239     var aliased = [ '-h', 'derp' ];
 240     var regular = [ '--herp',  'derp' ];
 241     var opts = {
 242         herp: { alias: 'h', boolean: true }
 243     };
 244     var aliasedArgv = parse(aliased, {
 245         boolean: 'herp',
 246         alias: { h: 'herp' }
 247     });
 248     var propertyArgv = parse(regular, {
 249         boolean: 'herp',
 250         alias: { h: 'herp' }
 251     });
 252     var expected = {
 253         herp: true,
 254         h: true,
 255         '_': [ 'derp' ]
 256     };
 257
 258     t.same(aliasedArgv, expected);
 259     t.same(propertyArgv, expected);
 260     t.end();
 261 });
 262
 263 test('boolean and alias with options hash', function (t) {
 264     var aliased = [ '-h', 'derp' ];
 265     var regular = [ '--herp', 'derp' ];
 266     var opts = {
 267         alias: { 'h': 'herp' },
 268         boolean: 'herp'
 269     };
 270     var aliasedArgv = parse(aliased, opts);
 271     var propertyArgv = parse(regular, opts);
 272     var expected = {
 273         herp: true,
 274         h: true,
 275         '_': [ 'derp' ]
 276     };
 277     t.same(aliasedArgv, expected);
 278     t.same(propertyArgv, expected);
 279     t.end();
 280 });
 281
 282 test('boolean and alias using explicit true', function (t) {
 283     var aliased = [ '-h', 'true' ];
 284     var regular = [ '--herp',  'true' ];
 285     var opts = {
 286         alias: { h: 'herp' },
 287         boolean: 'h'
 288     };
 289     var aliasedArgv = parse(aliased, opts);
 290     var propertyArgv = parse(regular, opts);
 291     var expected = {
 292         herp: true,
 293         h: true,
 294         '_': [ ]
 295     };
 296
 297     t.same(aliasedArgv, expected);
 298     t.same(propertyArgv, expected);
 299     t.end();
 300 });
 301
 302 // regression, see https://github.com/substack/node-optimist/issues/71
 303 test('boolean and --x=true', function(t) {
 304     var parsed = parse(['--boool', '--other=true'], {
 305         boolean: 'boool'
 306     });
 307
 308     t.same(parsed.boool, true);
 309     t.same(parsed.other, 'true');
 310
 311     parsed = parse(['--boool', '--other=false'], {
 312         boolean: 'boool'
 313     });
 314
 315     t.same(parsed.boool, true);
 316     t.same(parsed.other, 'false');
 317     t.end();
 318 });