corrade-nucleus-nucleons – Blame information for rev 20

Subversion Repositories:
Rev:
Rev Author Line No. Line
20 office 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 });