Name: js-handler/node_modules/optimist/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('slashBreak', function (t) {
166:
    t.same(
167:
        parse([ '-I/foo/bar/baz' ]),
168:
        { I : '/foo/bar/baz', _ : [] }
169:
    );
170:
    t.same(
171:
        parse([ '-xyz/foo/bar/baz' ]),
172:
        { x : true, y : true, z : '/foo/bar/baz', _ : [] }
173:
    );
174:
    t.end();
175:
});
176:
 
177:
test('alias', function (t) {
178:
    var argv = parse([ '-f', '11', '--zoom', '55' ], {
179:
        alias: { z: 'zoom' }
180:
    });
181:
    t.equal(argv.zoom, 55);
182:
    t.equal(argv.z, argv.zoom);
183:
    t.equal(argv.f, 11);
184:
    t.end();
185:
});
186:
 
187:
test('multiAlias', function (t) {
188:
    var argv = parse([ '-f', '11', '--zoom', '55' ], {
189:
        alias: { z: [ 'zm', 'zoom' ] }
190:
    });
191:
    t.equal(argv.zoom, 55);
192:
    t.equal(argv.z, argv.zoom);
193:
    t.equal(argv.z, argv.zm);
194:
    t.equal(argv.f, 11);
195:
    t.end();
196:
});
197:
 
198:
test('nested dotted objects', function (t) {
199:
    var argv = parse([
200:
        '--foo.bar', '3', '--foo.baz', '4',
201:
        '--foo.quux.quibble', '5', '--foo.quux.o_O',
202:
        '--beep.boop'
203:
    ]);
204:
    
205:
    t.same(argv.foo, {
206:
        bar : 3,
207:
        baz : 4,
208:
        quux : {
209:
            quibble : 5,
210:
            o_O : true
211:
        }
212:
    });
213:
    t.same(argv.beep, { boop : true });
214:
    t.end();
215:
});
216:
 
217:
test('boolean and alias with chainable api', function (t) {
218:
    var aliased = [ '-h', 'derp' ];
219:
    var regular = [ '--herp',  'derp' ];
220:
    var opts = {
221:
        herp: { alias: 'h', boolean: true }
222:
    };
223:
    var aliasedArgv = parse(aliased, {
224:
        boolean: 'herp',
225:
        alias: { h: 'herp' }
226:
    });
227:
    var propertyArgv = parse(regular, {
228:
        boolean: 'herp',
229:
        alias: { h: 'herp' }
230:
    });
231:
    var expected = {
232:
        herp: true,
233:
        h: true,
234:
        '_': [ 'derp' ]
235:
    };
236:
    
237:
    t.same(aliasedArgv, expected);
238:
    t.same(propertyArgv, expected);
239:
    t.end();
240:
});
241:
 
242:
test('boolean and alias with options hash', function (t) {
243:
    var aliased = [ '-h', 'derp' ];
244:
    var regular = [ '--herp', 'derp' ];
245:
    var opts = {
246:
        alias: { 'h': 'herp' },
247:
        boolean: 'herp'
248:
    };
249:
    var aliasedArgv = parse(aliased, opts);
250:
    var propertyArgv = parse(regular, opts);
251:
    var expected = {
252:
        herp: true,
253:
        h: true,
254:
        '_': [ 'derp' ]
255:
    };
256:
    t.same(aliasedArgv, expected);
257:
    t.same(propertyArgv, expected);
258:
    t.end();
259:
});
260:
 
261:
test('boolean and alias using explicit true', function (t) {
262:
    var aliased = [ '-h', 'true' ];
263:
    var regular = [ '--herp',  'true' ];
264:
    var opts = {
265:
        alias: { h: 'herp' },
266:
        boolean: 'h'
267:
    };
268:
    var aliasedArgv = parse(aliased, opts);
269:
    var propertyArgv = parse(regular, opts);
270:
    var expected = {
271:
        herp: true,
272:
        h: true,
273:
        '_': [ ]
274:
    };
275:
 
276:
    t.same(aliasedArgv, expected);
277:
    t.same(propertyArgv, expected);
278:
    t.end();
279:
});
280:
 
281:
// regression, see https://github.com/substack/node-optimist/issues/71
282:
test('boolean and --x=true', function(t) {
283:
    var parsed = parse(['--boool', '--other=true'], {
284:
        boolean: 'boool'
285:
    });
286:
 
287:
    t.same(parsed.boool, true);
288:
    t.same(parsed.other, 'true');
289:
 
290:
    parsed = parse(['--boool', '--other=false'], {
291:
        boolean: 'boool'
292:
    });
293:
    
294:
    t.same(parsed.boool, true);
295:
    t.same(parsed.other, 'false');
296:
    t.end();
297:
});