corrade-nucleus-nucleons – Blame information for rev 20
?pathlinks?
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 | }); |