Skip to content

Commit 5368ca4

Browse files
ljharbljharb
committedOct 16, 2022
[eslint] fix indentation and whitespace
·
v1.2.8
1 parent 980d7ac commit 5368ca4

19 files changed

+1002
-1009
lines changed
 

‎.eslintrc

+36-50
Original file line numberDiff line numberDiff line change
@@ -1,54 +1,40 @@
11
{
2-
"root": true,
2+
"root": true,
33

4-
"extends": "@ljharb/eslint-config/node/0.4",
4+
"extends": "@ljharb/eslint-config/node/0.4",
55

6-
"rules": {
7-
"array-bracket-spacing": 0,
8-
"array-element-newline": 0,
9-
"brace-style": 1,
10-
"camelcase": 1,
11-
"comma-dangle": 1,
12-
"comma-spacing": 1,
13-
"complexity": 0,
14-
"curly": 1,
15-
"dot-notation": 1,
16-
"eol-last": 1,
17-
"func-style": 1,
18-
"function-paren-newline": 1,
19-
"indent": [1, 4],
20-
"key-spacing": 1,
21-
"max-lines-per-function": 0,
22-
"max-nested-callbacks": 1,
23-
"max-statements": 0,
24-
"multiline-comment-style": 1,
25-
"no-array-constructor": 1,
26-
"no-continue": 1,
27-
"no-div-regex": 1,
28-
"no-extra-parens": 1,
29-
"no-mixed-operators": 1,
30-
"no-multi-spaces": 1,
31-
"no-multiple-empty-lines": 1,
32-
"no-param-reassign": 1,
33-
"no-plusplus": 1,
34-
"no-proto": 1,
35-
"no-redeclare": 1,
36-
"no-restricted-syntax": 1,
37-
"no-shadow": 1,
38-
"no-trailing-spaces": 1,
39-
"no-unused-vars": 1,
40-
"no-use-before-define": 1,
41-
"object-curly-newline": 1,
42-
"object-curly-spacing": 1,
43-
"operator-linebreak": 1,
44-
"quote-props": 1,
45-
"quotes": 1,
46-
"semi-style": 1,
47-
"semi": 1,
48-
"space-before-blocks": 1,
49-
"space-before-function-paren": 1,
50-
"space-infix-ops": 1,
51-
"strict": 1,
52-
"wrap-regex": 1,
53-
},
6+
"rules": {
7+
"array-element-newline": 0,
8+
"camelcase": 1,
9+
"comma-dangle": 1,
10+
"complexity": 0,
11+
"curly": 1,
12+
"dot-notation": 1,
13+
"func-style": 1,
14+
"max-lines-per-function": 0,
15+
"max-nested-callbacks": 1,
16+
"max-statements": 0,
17+
"multiline-comment-style": 0,
18+
"no-array-constructor": 1,
19+
"no-continue": 1,
20+
"no-div-regex": 1,
21+
"no-extra-parens": 1,
22+
"no-mixed-operators": 1,
23+
"no-param-reassign": 1,
24+
"no-plusplus": 1,
25+
"no-proto": 1,
26+
"no-redeclare": 1,
27+
"no-restricted-syntax": 1,
28+
"no-shadow": 1,
29+
"no-unused-vars": 1,
30+
"no-use-before-define": 1,
31+
"object-curly-newline": 1,
32+
"operator-linebreak": 1,
33+
"quote-props": 1,
34+
"quotes": 1,
35+
"semi-style": 1,
36+
"semi": 1,
37+
"strict": 1,
38+
"wrap-regex": 1,
39+
},
5440
}

‎README.md

+14-10
Original file line numberDiff line numberDiff line change
@@ -26,14 +26,16 @@ $ node example/parse.js -a beep -b boop
2626

2727
```
2828
$ node example/parse.js -x 3 -y 4 -n5 -abc --beep=boop foo bar baz
29-
{ _: [ 'foo', 'bar', 'baz' ],
30-
x: 3,
31-
y: 4,
32-
n: 5,
33-
a: true,
34-
b: true,
35-
c: true,
36-
beep: 'boop' }
29+
{
30+
_: ['foo', 'bar', 'baz'],
31+
x: 3,
32+
y: 4,
33+
n: 5,
34+
a: true,
35+
b: true,
36+
c: true,
37+
beep: 'boop'
38+
}
3739
```
3840

3941
# security
@@ -81,8 +83,10 @@ and `argv['--']` with everything after the `--`. Here's an example:
8183

8284
```
8385
> require('./')('one two three -- four five --six'.split(' '), { '--': true })
84-
{ _: [ 'one', 'two', 'three' ],
85-
'--': [ 'four', 'five', '--six' ] }
86+
{
87+
_: ['one', 'two', 'three'],
88+
'--': ['four', 'five', '--six']
89+
}
8690
```
8791

8892
Note that with `opts['--']` set, parsing for arguments still stops after the

‎index.js

+243-240
Large diffs are not rendered by default.

‎package.json

+73-73
Original file line numberDiff line numberDiff line change
@@ -1,75 +1,75 @@
11
{
2-
"name": "minimist",
3-
"version": "1.2.7",
4-
"description": "parse argument options",
5-
"main": "index.js",
6-
"devDependencies": {
7-
"@ljharb/eslint-config": "^21.0.0",
8-
"aud": "^2.0.1",
9-
"auto-changelog": "^2.4.0",
10-
"eslint": "=8.8.0",
11-
"in-publish": "^2.0.1",
12-
"npmignore": "^0.3.0",
13-
"nyc": "^10.3.2",
14-
"safe-publish-latest": "^2.0.0",
15-
"tape": "^5.6.1"
16-
},
17-
"scripts": {
18-
"prepack": "npmignore --auto --commentLines=auto",
19-
"prepublishOnly": "safe-publish-latest",
20-
"prepublish": "not-in-publish || npm run prepublishOnly",
21-
"lint": "eslint --ext=js,mjs .",
22-
"pretest": "npm run lint",
23-
"tests-only": "nyc tape test/*.js",
24-
"test": "npm run tests-only",
25-
"posttest": "aud --production",
26-
"version": "auto-changelog && git add CHANGELOG.md",
27-
"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
28-
},
29-
"testling": {
30-
"files": "test/*.js",
31-
"browsers": [
32-
"ie/6..latest",
33-
"ff/5",
34-
"firefox/latest",
35-
"chrome/10",
36-
"chrome/latest",
37-
"safari/5.1",
38-
"safari/latest",
39-
"opera/12"
40-
]
41-
},
42-
"repository": {
43-
"type": "git",
44-
"url": "git://github.com/minimistjs/minimist.git"
45-
},
46-
"homepage": "https://github.com/minimistjs/minimist",
47-
"keywords": [
48-
"argv",
49-
"getopt",
50-
"parser",
51-
"optimist"
52-
],
53-
"author": {
54-
"name": "James Halliday",
55-
"email": "mail@substack.net",
56-
"url": "http://substack.net"
57-
},
58-
"funding": {
59-
"url": "https://github.com/sponsors/ljharb"
60-
},
61-
"license": "MIT",
62-
"auto-changelog": {
63-
"output": "CHANGELOG.md",
64-
"template": "keepachangelog",
65-
"unreleased": false,
66-
"commitLimit": false,
67-
"backfillLimit": false,
68-
"hideCredit": true
69-
},
70-
"publishConfig": {
71-
"ignore": [
72-
".github/workflows"
73-
]
74-
}
2+
"name": "minimist",
3+
"version": "1.2.7",
4+
"description": "parse argument options",
5+
"main": "index.js",
6+
"devDependencies": {
7+
"@ljharb/eslint-config": "^21.0.0",
8+
"aud": "^2.0.1",
9+
"auto-changelog": "^2.4.0",
10+
"eslint": "=8.8.0",
11+
"in-publish": "^2.0.1",
12+
"npmignore": "^0.3.0",
13+
"nyc": "^10.3.2",
14+
"safe-publish-latest": "^2.0.0",
15+
"tape": "^5.6.1"
16+
},
17+
"scripts": {
18+
"prepack": "npmignore --auto --commentLines=auto",
19+
"prepublishOnly": "safe-publish-latest",
20+
"prepublish": "not-in-publish || npm run prepublishOnly",
21+
"lint": "eslint --ext=js,mjs .",
22+
"pretest": "npm run lint",
23+
"tests-only": "nyc tape test/*.js",
24+
"test": "npm run tests-only",
25+
"posttest": "aud --production",
26+
"version": "auto-changelog && git add CHANGELOG.md",
27+
"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
28+
},
29+
"testling": {
30+
"files": "test/*.js",
31+
"browsers": [
32+
"ie/6..latest",
33+
"ff/5",
34+
"firefox/latest",
35+
"chrome/10",
36+
"chrome/latest",
37+
"safari/5.1",
38+
"safari/latest",
39+
"opera/12"
40+
]
41+
},
42+
"repository": {
43+
"type": "git",
44+
"url": "git://github.com/minimistjs/minimist.git"
45+
},
46+
"homepage": "https://github.com/minimistjs/minimist",
47+
"keywords": [
48+
"argv",
49+
"getopt",
50+
"parser",
51+
"optimist"
52+
],
53+
"author": {
54+
"name": "James Halliday",
55+
"email": "mail@substack.net",
56+
"url": "http://substack.net"
57+
},
58+
"funding": {
59+
"url": "https://github.com/sponsors/ljharb"
60+
},
61+
"license": "MIT",
62+
"auto-changelog": {
63+
"output": "CHANGELOG.md",
64+
"template": "keepachangelog",
65+
"unreleased": false,
66+
"commitLimit": false,
67+
"backfillLimit": false,
68+
"hideCredit": true
69+
},
70+
"publishConfig": {
71+
"ignore": [
72+
".github/workflows"
73+
]
74+
}
7575
}

‎test/all_bool.js

+24-24
Original file line numberDiff line numberDiff line change
@@ -2,31 +2,31 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('flag boolean true (default all --args to boolean)', function (t) {
5-
var argv = parse(['moo', '--honk', 'cow'], {
6-
boolean: true
7-
});
8-
9-
t.deepEqual(argv, {
10-
honk: true,
11-
_: ['moo', 'cow']
12-
});
13-
14-
t.deepEqual(typeof argv.honk, 'boolean');
15-
t.end();
5+
var argv = parse(['moo', '--honk', 'cow'], {
6+
boolean: true
7+
});
8+
9+
t.deepEqual(argv, {
10+
honk: true,
11+
_: ['moo', 'cow']
12+
});
13+
14+
t.deepEqual(typeof argv.honk, 'boolean');
15+
t.end();
1616
});
1717

1818
test('flag boolean true only affects double hyphen arguments without equals signs', function (t) {
19-
var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
20-
boolean: true
21-
});
22-
23-
t.deepEqual(argv, {
24-
honk: true,
25-
tacos: 'good',
26-
p: 55,
27-
_: ['moo', 'cow']
28-
});
29-
30-
t.deepEqual(typeof argv.honk, 'boolean');
31-
t.end();
19+
var argv = parse(['moo', '--honk', 'cow', '-p', '55', '--tacos=good'], {
20+
boolean: true
21+
});
22+
23+
t.deepEqual(argv, {
24+
honk: true,
25+
tacos: 'good',
26+
p: 55,
27+
_: ['moo', 'cow']
28+
});
29+
30+
t.deepEqual(typeof argv.honk, 'boolean');
31+
t.end();
3232
});

‎test/bool.js

+147-147
Original file line numberDiff line numberDiff line change
@@ -2,177 +2,177 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('flag boolean default false', function (t) {
5-
var argv = parse(['moo'], {
6-
boolean: ['t', 'verbose'],
7-
default: { verbose: false, t: false }
8-
});
9-
10-
t.deepEqual(argv, {
11-
verbose: false,
12-
t: false,
13-
_: ['moo']
14-
});
15-
16-
t.deepEqual(typeof argv.verbose, 'boolean');
17-
t.deepEqual(typeof argv.t, 'boolean');
18-
t.end();
5+
var argv = parse(['moo'], {
6+
boolean: ['t', 'verbose'],
7+
default: { verbose: false, t: false }
8+
});
9+
10+
t.deepEqual(argv, {
11+
verbose: false,
12+
t: false,
13+
_: ['moo']
14+
});
15+
16+
t.deepEqual(typeof argv.verbose, 'boolean');
17+
t.deepEqual(typeof argv.t, 'boolean');
18+
t.end();
1919

2020
});
2121

2222
test('boolean groups', function (t) {
23-
var argv = parse([ '-x', '-z', 'one', 'two', 'three' ], {
24-
boolean: ['x','y','z']
25-
});
26-
27-
t.deepEqual(argv, {
28-
x : true,
29-
y : false,
30-
z : true,
31-
_ : [ 'one', 'two', 'three' ]
32-
});
33-
34-
t.deepEqual(typeof argv.x, 'boolean');
35-
t.deepEqual(typeof argv.y, 'boolean');
36-
t.deepEqual(typeof argv.z, 'boolean');
37-
t.end();
23+
var argv = parse(['-x', '-z', 'one', 'two', 'three'], {
24+
boolean: ['x', 'y', 'z']
25+
});
26+
27+
t.deepEqual(argv, {
28+
x: true,
29+
y: false,
30+
z: true,
31+
_: ['one', 'two', 'three']
32+
});
33+
34+
t.deepEqual(typeof argv.x, 'boolean');
35+
t.deepEqual(typeof argv.y, 'boolean');
36+
t.deepEqual(typeof argv.z, 'boolean');
37+
t.end();
3838
});
3939
test('boolean and alias with chainable api', function (t) {
40-
var aliased = [ '-h', 'derp' ];
41-
var regular = [ '--herp', 'derp' ];
42-
var opts = {
43-
herp: { alias: 'h', boolean: true }
44-
};
45-
var aliasedArgv = parse(aliased, {
46-
boolean: 'herp',
47-
alias: { h: 'herp' }
48-
});
49-
var propertyArgv = parse(regular, {
50-
boolean: 'herp',
51-
alias: { h: 'herp' }
52-
});
53-
var expected = {
54-
herp: true,
55-
h: true,
56-
'_': [ 'derp' ]
57-
};
58-
59-
t.same(aliasedArgv, expected);
60-
t.same(propertyArgv, expected);
61-
t.end();
40+
var aliased = ['-h', 'derp'];
41+
var regular = ['--herp', 'derp'];
42+
var opts = {
43+
herp: { alias: 'h', boolean: true }
44+
};
45+
var aliasedArgv = parse(aliased, {
46+
boolean: 'herp',
47+
alias: { h: 'herp' }
48+
});
49+
var propertyArgv = parse(regular, {
50+
boolean: 'herp',
51+
alias: { h: 'herp' }
52+
});
53+
var expected = {
54+
herp: true,
55+
h: true,
56+
'_': ['derp']
57+
};
58+
59+
t.same(aliasedArgv, expected);
60+
t.same(propertyArgv, expected);
61+
t.end();
6262
});
6363

6464
test('boolean and alias with options hash', function (t) {
65-
var aliased = [ '-h', 'derp' ];
66-
var regular = [ '--herp', 'derp' ];
67-
var opts = {
68-
alias: { 'h': 'herp' },
69-
boolean: 'herp'
70-
};
71-
var aliasedArgv = parse(aliased, opts);
72-
var propertyArgv = parse(regular, opts);
73-
var expected = {
74-
herp: true,
75-
h: true,
76-
'_': [ 'derp' ]
77-
};
78-
t.same(aliasedArgv, expected);
79-
t.same(propertyArgv, expected);
80-
t.end();
65+
var aliased = ['-h', 'derp'];
66+
var regular = ['--herp', 'derp'];
67+
var opts = {
68+
alias: { 'h': 'herp' },
69+
boolean: 'herp'
70+
};
71+
var aliasedArgv = parse(aliased, opts);
72+
var propertyArgv = parse(regular, opts);
73+
var expected = {
74+
herp: true,
75+
h: true,
76+
'_': ['derp']
77+
};
78+
t.same(aliasedArgv, expected);
79+
t.same(propertyArgv, expected);
80+
t.end();
8181
});
8282

8383
test('boolean and alias array with options hash', function (t) {
84-
var aliased = [ '-h', 'derp' ];
85-
var regular = [ '--herp', 'derp' ];
86-
var alt = [ '--harp', 'derp' ];
87-
var opts = {
88-
alias: { 'h': ['herp', 'harp'] },
89-
boolean: 'h'
90-
};
91-
var aliasedArgv = parse(aliased, opts);
92-
var propertyArgv = parse(regular, opts);
93-
var altPropertyArgv = parse(alt, opts);
94-
var expected = {
95-
harp: true,
96-
herp: true,
97-
h: true,
98-
'_': [ 'derp' ]
99-
};
100-
t.same(aliasedArgv, expected);
101-
t.same(propertyArgv, expected);
102-
t.same(altPropertyArgv, expected);
103-
t.end();
84+
var aliased = ['-h', 'derp'];
85+
var regular = ['--herp', 'derp'];
86+
var alt = ['--harp', 'derp'];
87+
var opts = {
88+
alias: { 'h': ['herp', 'harp'] },
89+
boolean: 'h'
90+
};
91+
var aliasedArgv = parse(aliased, opts);
92+
var propertyArgv = parse(regular, opts);
93+
var altPropertyArgv = parse(alt, opts);
94+
var expected = {
95+
harp: true,
96+
herp: true,
97+
h: true,
98+
'_': ['derp']
99+
};
100+
t.same(aliasedArgv, expected);
101+
t.same(propertyArgv, expected);
102+
t.same(altPropertyArgv, expected);
103+
t.end();
104104
});
105105

106106
test('boolean and alias using explicit true', function (t) {
107-
var aliased = [ '-h', 'true' ];
108-
var regular = [ '--herp', 'true' ];
109-
var opts = {
110-
alias: { h: 'herp' },
111-
boolean: 'h'
112-
};
113-
var aliasedArgv = parse(aliased, opts);
114-
var propertyArgv = parse(regular, opts);
115-
var expected = {
116-
herp: true,
117-
h: true,
118-
'_': [ ]
119-
};
120-
121-
t.same(aliasedArgv, expected);
122-
t.same(propertyArgv, expected);
123-
t.end();
107+
var aliased = ['-h', 'true'];
108+
var regular = ['--herp', 'true'];
109+
var opts = {
110+
alias: { h: 'herp' },
111+
boolean: 'h'
112+
};
113+
var aliasedArgv = parse(aliased, opts);
114+
var propertyArgv = parse(regular, opts);
115+
var expected = {
116+
herp: true,
117+
h: true,
118+
'_': []
119+
};
120+
121+
t.same(aliasedArgv, expected);
122+
t.same(propertyArgv, expected);
123+
t.end();
124124
});
125125

126126
// regression, see https://github.com/substack/node-optimist/issues/71
127-
test('boolean and --x=true', function(t) {
128-
var parsed = parse(['--boool', '--other=true'], {
129-
boolean: 'boool'
130-
});
131-
132-
t.same(parsed.boool, true);
133-
t.same(parsed.other, 'true');
134-
135-
parsed = parse(['--boool', '--other=false'], {
136-
boolean: 'boool'
137-
});
138-
139-
t.same(parsed.boool, true);
140-
t.same(parsed.other, 'false');
141-
t.end();
127+
test('boolean and --x=true', function (t) {
128+
var parsed = parse(['--boool', '--other=true'], {
129+
boolean: 'boool'
130+
});
131+
132+
t.same(parsed.boool, true);
133+
t.same(parsed.other, 'true');
134+
135+
parsed = parse(['--boool', '--other=false'], {
136+
boolean: 'boool'
137+
});
138+
139+
t.same(parsed.boool, true);
140+
t.same(parsed.other, 'false');
141+
t.end();
142142
});
143143

144144
test('boolean --boool=true', function (t) {
145-
var parsed = parse(['--boool=true'], {
146-
default: {
147-
boool: false
148-
},
149-
boolean: ['boool']
150-
});
151-
152-
t.same(parsed.boool, true);
153-
t.end();
145+
var parsed = parse(['--boool=true'], {
146+
default: {
147+
boool: false
148+
},
149+
boolean: ['boool']
150+
});
151+
152+
t.same(parsed.boool, true);
153+
t.end();
154154
});
155155

156156
test('boolean --boool=false', function (t) {
157-
var parsed = parse(['--boool=false'], {
158-
default: {
159-
boool: true
160-
},
161-
boolean: ['boool']
162-
});
163-
164-
t.same(parsed.boool, false);
165-
t.end();
157+
var parsed = parse(['--boool=false'], {
158+
default: {
159+
boool: true
160+
},
161+
boolean: ['boool']
162+
});
163+
164+
t.same(parsed.boool, false);
165+
t.end();
166166
});
167167

168168
test('boolean using something similar to true', function (t) {
169-
var opts = { boolean: 'h' };
170-
var result = parse(['-h', 'true.txt'], opts);
171-
var expected = {
172-
h: true,
173-
'_': ['true.txt']
174-
};
175-
176-
t.same(result, expected);
177-
t.end();
178-
});
169+
var opts = { boolean: 'h' };
170+
var result = parse(['-h', 'true.txt'], opts);
171+
var expected = {
172+
h: true,
173+
'_': ['true.txt']
174+
};
175+
176+
t.same(result, expected);
177+
t.end();
178+
});

‎test/dash.js

+22-21
Original file line numberDiff line numberDiff line change
@@ -2,30 +2,31 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('-', function (t) {
5-
t.plan(5);
6-
t.deepEqual(parse([ '-n', '-' ]), { n: '-', _: [] });
7-
t.deepEqual(parse([ '-' ]), { _: [ '-' ] });
8-
t.deepEqual(parse([ '-f-' ]), { f: '-', _: [] });
9-
t.deepEqual(
10-
parse([ '-b', '-' ], { boolean: 'b' }),
11-
{ b: true, _: [ '-' ] }
12-
);
13-
t.deepEqual(
14-
parse([ '-s', '-' ], { string: 's' }),
15-
{ s: '-', _: [] }
16-
);
5+
t.plan(5);
6+
t.deepEqual(parse(['-n', '-']), { n: '-', _: [] });
7+
t.deepEqual(parse(['-']), { _: ['-'] });
8+
t.deepEqual(parse(['-f-']), { f: '-', _: [] });
9+
t.deepEqual(
10+
parse(['-b', '-'], { boolean: 'b' }),
11+
{ b: true, _: ['-'] }
12+
);
13+
t.deepEqual(
14+
parse(['-s', '-'], { string: 's' }),
15+
{ s: '-', _: [] }
16+
);
1717
});
1818

1919
test('-a -- b', function (t) {
20-
t.plan(3);
21-
t.deepEqual(parse([ '-a', '--', 'b' ]), { a: true, _: [ 'b' ] });
22-
t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
23-
t.deepEqual(parse([ '--a', '--', 'b' ]), { a: true, _: [ 'b' ] });
20+
t.plan(3);
21+
t.deepEqual(parse(['-a', '--', 'b']), { a: true, _: ['b'] });
22+
t.deepEqual(parse(['--a', '--', 'b']), { a: true, _: ['b'] });
23+
t.deepEqual(parse(['--a', '--', 'b']), { a: true, _: ['b'] });
2424
});
2525

26-
test('move arguments after the -- into their own `--` array', function(t) {
27-
t.plan(1);
28-
t.deepEqual(
29-
parse([ '--name', 'John', 'before', '--', 'after' ], { '--': true }),
30-
{ name: 'John', _: [ 'before' ], '--': [ 'after' ] });
26+
test('move arguments after the -- into their own `--` array', function (t) {
27+
t.plan(1);
28+
t.deepEqual(
29+
parse(['--name', 'John', 'before', '--', 'after'], { '--': true }),
30+
{ name: 'John', _: ['before'], '--': ['after'] }
31+
);
3132
});

‎test/default_bool.js

+23-23
Original file line numberDiff line numberDiff line change
@@ -2,34 +2,34 @@ var test = require('tape');
22
var parse = require('../');
33

44
test('boolean default true', function (t) {
5-
var argv = parse([], {
6-
boolean: 'sometrue',
7-
default: { sometrue: true }
8-
});
9-
t.equal(argv.sometrue, true);
10-
t.end();
5+
var argv = parse([], {
6+
boolean: 'sometrue',
7+
default: { sometrue: true }
8+
});
9+
t.equal(argv.sometrue, true);
10+
t.end();
1111
});
1212

1313
test('boolean default false', function (t) {
14-
var argv = parse([], {
15-
boolean: 'somefalse',
16-
default: { somefalse: false }
17-
});
18-
t.equal(argv.somefalse, false);
19-
t.end();
14+
var argv = parse([], {
15+
boolean: 'somefalse',
16+
default: { somefalse: false }
17+
});
18+
t.equal(argv.somefalse, false);
19+
t.end();
2020
});
2121

2222
test('boolean default to null', function (t) {
23-
var argv = parse([], {
24-
boolean: 'maybe',
25-
default: { maybe: null }
26-
});
27-
t.equal(argv.maybe, null);
28-
var argv = parse(['--maybe'], {
29-
boolean: 'maybe',
30-
default: { maybe: null }
31-
});
32-
t.equal(argv.maybe, true);
33-
t.end();
23+
var argv = parse([], {
24+
boolean: 'maybe',
25+
default: { maybe: null }
26+
});
27+
t.equal(argv.maybe, null);
28+
var argv = parse(['--maybe'], {
29+
boolean: 'maybe',
30+
default: { maybe: null }
31+
});
32+
t.equal(argv.maybe, true);
33+
t.end();
3434

3535
})

‎test/dotted.js

+11-11
Original file line numberDiff line numberDiff line change
@@ -2,21 +2,21 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('dotted alias', function (t) {
5-
var argv = parse(['--a.b', '22'], {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}});
6-
t.equal(argv.a.b, 22);
7-
t.equal(argv.aa.bb, 22);
8-
t.end();
5+
var argv = parse(['--a.b', '22'], { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } });
6+
t.equal(argv.a.b, 22);
7+
t.equal(argv.aa.bb, 22);
8+
t.end();
99
});
1010

1111
test('dotted default', function (t) {
12-
var argv = parse('', {default: {'a.b': 11}, alias: {'a.b': 'aa.bb'}});
13-
t.equal(argv.a.b, 11);
14-
t.equal(argv.aa.bb, 11);
15-
t.end();
12+
var argv = parse('', { default: { 'a.b': 11 }, alias: { 'a.b': 'aa.bb' } });
13+
t.equal(argv.a.b, 11);
14+
t.equal(argv.aa.bb, 11);
15+
t.end();
1616
});
1717

1818
test('dotted default with no alias', function (t) {
19-
var argv = parse('', {default: {'a.b': 11}});
20-
t.equal(argv.a.b, 11);
21-
t.end();
19+
var argv = parse('', { default: { 'a.b': 11 } });
20+
t.equal(argv.a.b, 11);
21+
t.end();
2222
});

‎test/kv_short.js

+10-10
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
11
var parse = require('../');
22
var test = require('tape');
33

4-
test('short -k=v' , function (t) {
5-
t.plan(1);
6-
7-
var argv = parse([ '-b=123' ]);
8-
t.deepEqual(argv, { b: 123, _: [] });
4+
test('short -k=v', function (t) {
5+
t.plan(1);
6+
7+
var argv = parse(['-b=123']);
8+
t.deepEqual(argv, { b: 123, _: [] });
99
});
1010

11-
test('multi short -k=v' , function (t) {
12-
t.plan(1);
13-
14-
var argv = parse([ '-a=whatever', '-b=robots' ]);
15-
t.deepEqual(argv, { a: 'whatever', b: 'robots', _: [] });
11+
test('multi short -k=v', function (t) {
12+
t.plan(1);
13+
14+
var argv = parse(['-a=whatever', '-b=robots']);
15+
t.deepEqual(argv, { a: 'whatever', b: 'robots', _: [] });
1616
});

‎test/long.js

+26-26
Original file line numberDiff line numberDiff line change
@@ -2,30 +2,30 @@ var test = require('tape');
22
var parse = require('../');
33

44
test('long opts', function (t) {
5-
t.deepEqual(
6-
parse([ '--bool' ]),
7-
{ bool : true, _ : [] },
8-
'long boolean'
9-
);
10-
t.deepEqual(
11-
parse([ '--pow', 'xixxle' ]),
12-
{ pow : 'xixxle', _ : [] },
13-
'long capture sp'
14-
);
15-
t.deepEqual(
16-
parse([ '--pow=xixxle' ]),
17-
{ pow : 'xixxle', _ : [] },
18-
'long capture eq'
19-
);
20-
t.deepEqual(
21-
parse([ '--host', 'localhost', '--port', '555' ]),
22-
{ host : 'localhost', port : 555, _ : [] },
23-
'long captures sp'
24-
);
25-
t.deepEqual(
26-
parse([ '--host=localhost', '--port=555' ]),
27-
{ host : 'localhost', port : 555, _ : [] },
28-
'long captures eq'
29-
);
30-
t.end();
5+
t.deepEqual(
6+
parse(['--bool']),
7+
{ bool: true, _: [] },
8+
'long boolean'
9+
);
10+
t.deepEqual(
11+
parse(['--pow', 'xixxle']),
12+
{ pow: 'xixxle', _: [] },
13+
'long capture sp'
14+
);
15+
t.deepEqual(
16+
parse(['--pow=xixxle']),
17+
{ pow: 'xixxle', _: [] },
18+
'long capture eq'
19+
);
20+
t.deepEqual(
21+
parse(['--host', 'localhost', '--port', '555']),
22+
{ host: 'localhost', port: 555, _: [] },
23+
'long captures sp'
24+
);
25+
t.deepEqual(
26+
parse(['--host=localhost', '--port=555']),
27+
{ host: 'localhost', port: 555, _: [] },
28+
'long captures eq'
29+
);
30+
t.end();
3131
});

‎test/num.js

+28-28
Original file line numberDiff line numberDiff line change
@@ -2,35 +2,35 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('nums', function (t) {
5-
var argv = parse([
6-
'-x', '1234',
7-
'-y', '5.67',
8-
'-z', '1e7',
9-
'-w', '10f',
10-
'--hex', '0xdeadbeef',
11-
'789'
12-
]);
13-
t.deepEqual(argv, {
14-
x : 1234,
15-
y : 5.67,
16-
z : 1e7,
17-
w : '10f',
18-
hex : 0xdeadbeef,
19-
_ : [ 789 ]
20-
});
21-
t.deepEqual(typeof argv.x, 'number');
22-
t.deepEqual(typeof argv.y, 'number');
23-
t.deepEqual(typeof argv.z, 'number');
24-
t.deepEqual(typeof argv.w, 'string');
25-
t.deepEqual(typeof argv.hex, 'number');
26-
t.deepEqual(typeof argv._[0], 'number');
27-
t.end();
5+
var argv = parse([
6+
'-x', '1234',
7+
'-y', '5.67',
8+
'-z', '1e7',
9+
'-w', '10f',
10+
'--hex', '0xdeadbeef',
11+
'789'
12+
]);
13+
t.deepEqual(argv, {
14+
x: 1234,
15+
y: 5.67,
16+
z: 1e7,
17+
w: '10f',
18+
hex: 0xdeadbeef,
19+
_: [789]
20+
});
21+
t.deepEqual(typeof argv.x, 'number');
22+
t.deepEqual(typeof argv.y, 'number');
23+
t.deepEqual(typeof argv.z, 'number');
24+
t.deepEqual(typeof argv.w, 'string');
25+
t.deepEqual(typeof argv.hex, 'number');
26+
t.deepEqual(typeof argv._[0], 'number');
27+
t.end();
2828
});
2929

3030
test('already a number', function (t) {
31-
var argv = parse([ '-x', 1234, 789 ]);
32-
t.deepEqual(argv, { x : 1234, _ : [ 789 ] });
33-
t.deepEqual(typeof argv.x, 'number');
34-
t.deepEqual(typeof argv._[0], 'number');
35-
t.end();
31+
var argv = parse(['-x', 1234, 789]);
32+
t.deepEqual(argv, { x: 1234, _: [789] });
33+
t.deepEqual(typeof argv.x, 'number');
34+
t.deepEqual(typeof argv._[0], 'number');
35+
t.end();
3636
});

‎test/parse.js

+156-157
Original file line numberDiff line numberDiff line change
@@ -2,196 +2,195 @@ var parse = require('../');
22
var test = require('tape');
33

44
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();
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();
1616
});
17-
17+
1818
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();
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();
4343
});
4444

4545
test('flag boolean', function (t) {
46-
var argv = parse([ '-t', 'moo' ], { boolean: 't' });
47-
t.deepEqual(argv, { t : true, _ : [ 'moo' ] });
48-
t.deepEqual(typeof argv.t, 'boolean');
49-
t.end();
46+
var argv = parse(['-t', 'moo'], { boolean: 't' });
47+
t.deepEqual(argv, { t: true, _: ['moo'] });
48+
t.deepEqual(typeof argv.t, 'boolean');
49+
t.end();
5050
});
5151

5252
test('flag boolean value', function (t) {
53-
var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], {
54-
boolean: [ 't', 'verbose' ],
55-
default: { verbose: true }
56-
});
57-
58-
t.deepEqual(argv, {
59-
verbose: false,
60-
t: true,
61-
_: ['moo']
62-
});
63-
64-
t.deepEqual(typeof argv.verbose, 'boolean');
65-
t.deepEqual(typeof argv.t, 'boolean');
66-
t.end();
53+
var argv = parse(['--verbose', 'false', 'moo', '-t', 'true'], {
54+
boolean: ['t', 'verbose'],
55+
default: { verbose: true }
56+
});
57+
58+
t.deepEqual(argv, {
59+
verbose: false,
60+
t: true,
61+
_: ['moo']
62+
});
63+
64+
t.deepEqual(typeof argv.verbose, 'boolean');
65+
t.deepEqual(typeof argv.t, 'boolean');
66+
t.end();
6767
});
6868

69-
test('newlines in params' , function (t) {
70-
var args = parse([ '-s', "X\nX" ])
71-
t.deepEqual(args, { _ : [], s : "X\nX" });
72-
73-
// reproduce in bash:
74-
// VALUE="new
75-
// line"
76-
// node program.js --s="$VALUE"
77-
args = parse([ "--s=X\nX" ])
78-
t.deepEqual(args, { _ : [], s : "X\nX" });
79-
t.end();
69+
test('newlines in params', function (t) {
70+
var args = parse(['-s', "X\nX"])
71+
t.deepEqual(args, { _: [], s: "X\nX" });
72+
73+
// reproduce in bash:
74+
// VALUE="new
75+
// line"
76+
// node program.js --s="$VALUE"
77+
args = parse(["--s=X\nX"])
78+
t.deepEqual(args, { _: [], s: "X\nX" });
79+
t.end();
8080
});
8181

82-
test('strings' , function (t) {
83-
var s = parse([ '-s', '0001234' ], { string: 's' }).s;
84-
t.equal(s, '0001234');
85-
t.equal(typeof s, 'string');
86-
87-
var x = parse([ '-x', '56' ], { string: 'x' }).x;
88-
t.equal(x, '56');
89-
t.equal(typeof x, 'string');
90-
t.end();
82+
test('strings', function (t) {
83+
var s = parse(['-s', '0001234'], { string: 's' }).s;
84+
t.equal(s, '0001234');
85+
t.equal(typeof s, 'string');
86+
87+
var x = parse(['-x', '56'], { string: 'x' }).x;
88+
t.equal(x, '56');
89+
t.equal(typeof x, 'string');
90+
t.end();
9191
});
9292

9393
test('stringArgs', function (t) {
94-
var s = parse([ ' ', ' ' ], { string: '_' })._;
95-
t.same(s.length, 2);
96-
t.same(typeof s[0], 'string');
97-
t.same(s[0], ' ');
98-
t.same(typeof s[1], 'string');
99-
t.same(s[1], ' ');
100-
t.end();
94+
var s = parse([' ', ' '], { string: '_' })._;
95+
t.same(s.length, 2);
96+
t.same(typeof s[0], 'string');
97+
t.same(s[0], ' ');
98+
t.same(typeof s[1], 'string');
99+
t.same(s[1], ' ');
100+
t.end();
101101
});
102102

103-
test('empty strings', function(t) {
104-
var s = parse([ '-s' ], { string: 's' }).s;
105-
t.equal(s, '');
106-
t.equal(typeof s, 'string');
103+
test('empty strings', function (t) {
104+
var s = parse(['-s'], { string: 's' }).s;
105+
t.equal(s, '');
106+
t.equal(typeof s, 'string');
107107

108-
var str = parse([ '--str' ], { string: 'str' }).str;
109-
t.equal(str, '');
110-
t.equal(typeof str, 'string');
108+
var str = parse(['--str'], { string: 'str' }).str;
109+
t.equal(str, '');
110+
t.equal(typeof str, 'string');
111111

112-
var letters = parse([ '-art' ], {
113-
string: [ 'a', 't' ]
114-
});
112+
var letters = parse(['-art'], {
113+
string: ['a', 't']
114+
});
115115

116-
t.equal(letters.a, '');
117-
t.equal(letters.r, true);
118-
t.equal(letters.t, '');
116+
t.equal(letters.a, '');
117+
t.equal(letters.r, true);
118+
t.equal(letters.t, '');
119119

120-
t.end();
120+
t.end();
121121
});
122122

123-
124-
test('string and alias', function(t) {
125-
var x = parse([ '--str', '000123' ], {
126-
string: 's',
127-
alias: { s: 'str' }
128-
});
129-
130-
t.equal(x.str, '000123');
131-
t.equal(typeof x.str, 'string');
132-
t.equal(x.s, '000123');
133-
t.equal(typeof x.s, 'string');
134-
135-
var y = parse([ '-s', '000123' ], {
136-
string: 'str',
137-
alias: { str: 's' }
138-
});
139-
140-
t.equal(y.str, '000123');
141-
t.equal(typeof y.str, 'string');
142-
t.equal(y.s, '000123');
143-
t.equal(typeof y.s, 'string');
144-
t.end();
123+
test('string and alias', function (t) {
124+
var x = parse(['--str', '000123'], {
125+
string: 's',
126+
alias: { s: 'str' }
127+
});
128+
129+
t.equal(x.str, '000123');
130+
t.equal(typeof x.str, 'string');
131+
t.equal(x.s, '000123');
132+
t.equal(typeof x.s, 'string');
133+
134+
var y = parse(['-s', '000123'], {
135+
string: 'str',
136+
alias: { str: 's' }
137+
});
138+
139+
t.equal(y.str, '000123');
140+
t.equal(typeof y.str, 'string');
141+
t.equal(y.s, '000123');
142+
t.equal(typeof y.s, 'string');
143+
t.end();
145144
});
146145

147146
test('slashBreak', function (t) {
148-
t.same(
149-
parse([ '-I/foo/bar/baz' ]),
150-
{ I : '/foo/bar/baz', _ : [] }
151-
);
152-
t.same(
153-
parse([ '-xyz/foo/bar/baz' ]),
154-
{ x : true, y : true, z : '/foo/bar/baz', _ : [] }
155-
);
156-
t.end();
147+
t.same(
148+
parse(['-I/foo/bar/baz']),
149+
{ I: '/foo/bar/baz', _: [] }
150+
);
151+
t.same(
152+
parse(['-xyz/foo/bar/baz']),
153+
{ x: true, y: true, z: '/foo/bar/baz', _: [] }
154+
);
155+
t.end();
157156
});
158157

159158
test('alias', function (t) {
160-
var argv = parse([ '-f', '11', '--zoom', '55' ], {
161-
alias: { z: 'zoom' }
162-
});
163-
t.equal(argv.zoom, 55);
164-
t.equal(argv.z, argv.zoom);
165-
t.equal(argv.f, 11);
166-
t.end();
159+
var argv = parse(['-f', '11', '--zoom', '55'], {
160+
alias: { z: 'zoom' }
161+
});
162+
t.equal(argv.zoom, 55);
163+
t.equal(argv.z, argv.zoom);
164+
t.equal(argv.f, 11);
165+
t.end();
167166
});
168167

169168
test('multiAlias', function (t) {
170-
var argv = parse([ '-f', '11', '--zoom', '55' ], {
171-
alias: { z: [ 'zm', 'zoom' ] }
172-
});
173-
t.equal(argv.zoom, 55);
174-
t.equal(argv.z, argv.zoom);
175-
t.equal(argv.z, argv.zm);
176-
t.equal(argv.f, 11);
177-
t.end();
169+
var argv = parse(['-f', '11', '--zoom', '55'], {
170+
alias: { z: ['zm', 'zoom'] }
171+
});
172+
t.equal(argv.zoom, 55);
173+
t.equal(argv.z, argv.zoom);
174+
t.equal(argv.z, argv.zm);
175+
t.equal(argv.f, 11);
176+
t.end();
178177
});
179178

180179
test('nested dotted objects', function (t) {
181-
var argv = parse([
182-
'--foo.bar', '3', '--foo.baz', '4',
183-
'--foo.quux.quibble', '5', '--foo.quux.o_O',
184-
'--beep.boop'
185-
]);
186-
187-
t.same(argv.foo, {
188-
bar : 3,
189-
baz : 4,
190-
quux : {
191-
quibble : 5,
192-
o_O : true
193-
}
194-
});
195-
t.same(argv.beep, { boop : true });
196-
t.end();
180+
var argv = parse([
181+
'--foo.bar', '3', '--foo.baz', '4',
182+
'--foo.quux.quibble', '5', '--foo.quux.o_O',
183+
'--beep.boop'
184+
]);
185+
186+
t.same(argv.foo, {
187+
bar: 3,
188+
baz: 4,
189+
quux: {
190+
quibble: 5,
191+
o_O: true
192+
}
193+
});
194+
t.same(argv.beep, { boop: true });
195+
t.end();
197196
});

‎test/parse_modified.js

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
var parse = require('../');
22
var test = require('tape');
33

4-
test('parse with modifier functions' , function (t) {
5-
t.plan(1);
6-
7-
var argv = parse([ '-b', '123' ], { boolean: 'b' });
8-
t.deepEqual(argv, { b: true, _: [123] });
4+
test('parse with modifier functions', function (t) {
5+
t.plan(1);
6+
7+
var argv = parse(['-b', '123'], { boolean: 'b' });
8+
t.deepEqual(argv, { b: true, _: [123] });
99
});

‎test/proto.js

+36-36
Original file line numberDiff line numberDiff line change
@@ -2,59 +2,59 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('proto pollution', function (t) {
5-
var argv = parse(['--__proto__.x','123']);
6-
t.equal({}.x, undefined);
7-
t.equal(argv.__proto__.x, undefined);
8-
t.equal(argv.x, undefined);
9-
t.end();
5+
var argv = parse(['--__proto__.x', '123']);
6+
t.equal({}.x, undefined);
7+
t.equal(argv.__proto__.x, undefined);
8+
t.equal(argv.x, undefined);
9+
t.end();
1010
});
1111

1212
test('proto pollution (array)', function (t) {
13-
var argv = parse(['--x','4','--x','5','--x.__proto__.z','789']);
14-
t.equal({}.z, undefined);
15-
t.deepEqual(argv.x, [4,5]);
16-
t.equal(argv.x.z, undefined);
17-
t.equal(argv.x.__proto__.z, undefined);
18-
t.end();
13+
var argv = parse(['--x', '4', '--x', '5', '--x.__proto__.z', '789']);
14+
t.equal({}.z, undefined);
15+
t.deepEqual(argv.x, [4, 5]);
16+
t.equal(argv.x.z, undefined);
17+
t.equal(argv.x.__proto__.z, undefined);
18+
t.end();
1919
});
2020

2121
test('proto pollution (number)', function (t) {
22-
var argv = parse(['--x','5','--x.__proto__.z','100']);
23-
t.equal({}.z, undefined);
24-
t.equal((4).z, undefined);
25-
t.equal(argv.x, 5);
26-
t.equal(argv.x.z, undefined);
27-
t.end();
22+
var argv = parse(['--x', '5', '--x.__proto__.z', '100']);
23+
t.equal({}.z, undefined);
24+
t.equal((4).z, undefined);
25+
t.equal(argv.x, 5);
26+
t.equal(argv.x.z, undefined);
27+
t.end();
2828
});
2929

3030
test('proto pollution (string)', function (t) {
31-
var argv = parse(['--x','abc','--x.__proto__.z','def']);
32-
t.equal({}.z, undefined);
33-
t.equal('...'.z, undefined);
34-
t.equal(argv.x, 'abc');
35-
t.equal(argv.x.z, undefined);
36-
t.end();
31+
var argv = parse(['--x', 'abc', '--x.__proto__.z', 'def']);
32+
t.equal({}.z, undefined);
33+
t.equal('...'.z, undefined);
34+
t.equal(argv.x, 'abc');
35+
t.equal(argv.x.z, undefined);
36+
t.end();
3737
});
3838

3939
test('proto pollution (constructor)', function (t) {
40-
var argv = parse(['--constructor.prototype.y','123']);
41-
t.equal({}.y, undefined);
42-
t.equal(argv.y, undefined);
43-
t.end();
40+
var argv = parse(['--constructor.prototype.y', '123']);
41+
t.equal({}.y, undefined);
42+
t.equal(argv.y, undefined);
43+
t.end();
4444
});
4545

4646
test('proto pollution (constructor function)', function (t) {
47-
var argv = parse(['--_.concat.constructor.prototype.y', '123']);
48-
function fnToBeTested() {}
49-
t.equal(fnToBeTested.y, undefined);
50-
t.equal(argv.y, undefined);
51-
t.end();
47+
var argv = parse(['--_.concat.constructor.prototype.y', '123']);
48+
function fnToBeTested() {}
49+
t.equal(fnToBeTested.y, undefined);
50+
t.equal(argv.y, undefined);
51+
t.end();
5252
});
5353

5454
// powered by snyk - https://github.com/backstage/backstage/issues/10343
5555
test('proto pollution (constructor function) snyk', function (t) {
56-
var argv = parse('--_.constructor.constructor.prototype.foo bar'.split(' '));
57-
t.equal((function(){}).foo, undefined);
58-
t.equal(argv.y, undefined);
59-
t.end();
56+
var argv = parse('--_.constructor.constructor.prototype.foo bar'.split(' '));
57+
t.equal((function () {}).foo, undefined);
58+
t.equal(argv.y, undefined);
59+
t.end();
6060
})

‎test/short.js

+55-55
Original file line numberDiff line numberDiff line change
@@ -2,66 +2,66 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('numeric short args', function (t) {
5-
t.plan(2);
6-
t.deepEqual(parse([ '-n123' ]), { n: 123, _: [] });
7-
t.deepEqual(
8-
parse([ '-123', '456' ]),
9-
{ 1: true, 2: true, 3: 456, _: [] }
10-
);
5+
t.plan(2);
6+
t.deepEqual(parse(['-n123']), { n: 123, _: [] });
7+
t.deepEqual(
8+
parse(['-123', '456']),
9+
{ 1: true, 2: true, 3: 456, _: [] }
10+
);
1111
});
1212

1313
test('short', function (t) {
14-
t.deepEqual(
15-
parse([ '-b' ]),
16-
{ b : true, _ : [] },
17-
'short boolean'
18-
);
19-
t.deepEqual(
20-
parse([ 'foo', 'bar', 'baz' ]),
21-
{ _ : [ 'foo', 'bar', 'baz' ] },
22-
'bare'
23-
);
24-
t.deepEqual(
25-
parse([ '-cats' ]),
26-
{ c : true, a : true, t : true, s : true, _ : [] },
27-
'group'
28-
);
29-
t.deepEqual(
30-
parse([ '-cats', 'meow' ]),
31-
{ c : true, a : true, t : true, s : 'meow', _ : [] },
32-
'short group next'
33-
);
34-
t.deepEqual(
35-
parse([ '-h', 'localhost' ]),
36-
{ h : 'localhost', _ : [] },
37-
'short capture'
38-
);
39-
t.deepEqual(
40-
parse([ '-h', 'localhost', '-p', '555' ]),
41-
{ h : 'localhost', p : 555, _ : [] },
42-
'short captures'
43-
);
44-
t.end();
14+
t.deepEqual(
15+
parse(['-b']),
16+
{ b: true, _: [] },
17+
'short boolean'
18+
);
19+
t.deepEqual(
20+
parse(['foo', 'bar', 'baz']),
21+
{ _: ['foo', 'bar', 'baz'] },
22+
'bare'
23+
);
24+
t.deepEqual(
25+
parse(['-cats']),
26+
{ c: true, a: true, t: true, s: true, _: [] },
27+
'group'
28+
);
29+
t.deepEqual(
30+
parse(['-cats', 'meow']),
31+
{ c: true, a: true, t: true, s: 'meow', _: [] },
32+
'short group next'
33+
);
34+
t.deepEqual(
35+
parse(['-h', 'localhost']),
36+
{ h: 'localhost', _: [] },
37+
'short capture'
38+
);
39+
t.deepEqual(
40+
parse(['-h', 'localhost', '-p', '555']),
41+
{ h: 'localhost', p: 555, _: [] },
42+
'short captures'
43+
);
44+
t.end();
4545
});
46-
46+
4747
test('mixed short bool and capture', function (t) {
48-
t.same(
49-
parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
50-
{
51-
f : true, p : 555, h : 'localhost',
52-
_ : [ 'script.js' ]
53-
}
54-
);
55-
t.end();
48+
t.same(
49+
parse(['-h', 'localhost', '-fp', '555', 'script.js']),
50+
{
51+
f: true, p: 555, h: 'localhost',
52+
_: ['script.js']
53+
}
54+
);
55+
t.end();
5656
});
57-
57+
5858
test('short and long', function (t) {
59-
t.deepEqual(
60-
parse([ '-h', 'localhost', '-fp', '555', 'script.js' ]),
61-
{
62-
f : true, p : 555, h : 'localhost',
63-
_ : [ 'script.js' ]
64-
}
65-
);
66-
t.end();
59+
t.deepEqual(
60+
parse(['-h', 'localhost', '-fp', '555', 'script.js']),
61+
{
62+
f: true, p: 555, h: 'localhost',
63+
_: ['script.js']
64+
}
65+
);
66+
t.end();
6767
});

‎test/stop_early.js

+8-8
Original file line numberDiff line numberDiff line change
@@ -2,14 +2,14 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('stops parsing on the first non-option when stopEarly is set', function (t) {
5-
var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], {
6-
stopEarly: true
7-
});
5+
var argv = parse(['--aaa', 'bbb', 'ccc', '--ddd'], {
6+
stopEarly: true
7+
});
88

9-
t.deepEqual(argv, {
10-
aaa: 'bbb',
11-
_: ['ccc', '--ddd']
12-
});
9+
t.deepEqual(argv, {
10+
aaa: 'bbb',
11+
_: ['ccc', '--ddd']
12+
});
1313

14-
t.end();
14+
t.end();
1515
});

‎test/unknown.js

+81-81
Original file line numberDiff line numberDiff line change
@@ -2,101 +2,101 @@ var parse = require('../');
22
var test = require('tape');
33

44
test('boolean and alias is not unknown', function (t) {
5-
var unknown = [];
6-
function unknownFn(arg) {
7-
unknown.push(arg);
8-
return false;
9-
}
10-
var aliased = [ '-h', 'true', '--derp', 'true' ];
11-
var regular = [ '--herp', 'true', '-d', 'true' ];
12-
var opts = {
13-
alias: { h: 'herp' },
14-
boolean: 'h',
15-
unknown: unknownFn
16-
};
17-
var aliasedArgv = parse(aliased, opts);
18-
var propertyArgv = parse(regular, opts);
5+
var unknown = [];
6+
function unknownFn(arg) {
7+
unknown.push(arg);
8+
return false;
9+
}
10+
var aliased = ['-h', 'true', '--derp', 'true'];
11+
var regular = ['--herp', 'true', '-d', 'true'];
12+
var opts = {
13+
alias: { h: 'herp' },
14+
boolean: 'h',
15+
unknown: unknownFn
16+
};
17+
var aliasedArgv = parse(aliased, opts);
18+
var propertyArgv = parse(regular, opts);
1919

20-
t.same(unknown, ['--derp', '-d']);
21-
t.end();
20+
t.same(unknown, ['--derp', '-d']);
21+
t.end();
2222
});
2323

2424
test('flag boolean true any double hyphen argument is not unknown', function (t) {
25-
var unknown = [];
26-
function unknownFn(arg) {
27-
unknown.push(arg);
28-
return false;
29-
}
30-
var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], {
31-
boolean: true,
32-
unknown: unknownFn
33-
});
34-
t.same(unknown, ['--tacos=good', 'cow', '-p']);
35-
t.same(argv, {
36-
honk: true,
37-
_: []
38-
});
39-
t.end();
25+
var unknown = [];
26+
function unknownFn(arg) {
27+
unknown.push(arg);
28+
return false;
29+
}
30+
var argv = parse(['--honk', '--tacos=good', 'cow', '-p', '55'], {
31+
boolean: true,
32+
unknown: unknownFn
33+
});
34+
t.same(unknown, ['--tacos=good', 'cow', '-p']);
35+
t.same(argv, {
36+
honk: true,
37+
_: []
38+
});
39+
t.end();
4040
});
4141

4242
test('string and alias is not unknown', function (t) {
43-
var unknown = [];
44-
function unknownFn(arg) {
45-
unknown.push(arg);
46-
return false;
47-
}
48-
var aliased = [ '-h', 'hello', '--derp', 'goodbye' ];
49-
var regular = [ '--herp', 'hello', '-d', 'moon' ];
50-
var opts = {
51-
alias: { h: 'herp' },
52-
string: 'h',
53-
unknown: unknownFn
54-
};
55-
var aliasedArgv = parse(aliased, opts);
56-
var propertyArgv = parse(regular, opts);
43+
var unknown = [];
44+
function unknownFn(arg) {
45+
unknown.push(arg);
46+
return false;
47+
}
48+
var aliased = ['-h', 'hello', '--derp', 'goodbye'];
49+
var regular = ['--herp', 'hello', '-d', 'moon'];
50+
var opts = {
51+
alias: { h: 'herp' },
52+
string: 'h',
53+
unknown: unknownFn
54+
};
55+
var aliasedArgv = parse(aliased, opts);
56+
var propertyArgv = parse(regular, opts);
5757

58-
t.same(unknown, ['--derp', '-d']);
59-
t.end();
58+
t.same(unknown, ['--derp', '-d']);
59+
t.end();
6060
});
6161

6262
test('default and alias is not unknown', function (t) {
63-
var unknown = [];
64-
function unknownFn(arg) {
65-
unknown.push(arg);
66-
return false;
67-
}
68-
var aliased = [ '-h', 'hello' ];
69-
var regular = [ '--herp', 'hello' ];
70-
var opts = {
71-
default: { 'h': 'bar' },
72-
alias: { 'h': 'herp' },
73-
unknown: unknownFn
74-
};
75-
var aliasedArgv = parse(aliased, opts);
76-
var propertyArgv = parse(regular, opts);
63+
var unknown = [];
64+
function unknownFn(arg) {
65+
unknown.push(arg);
66+
return false;
67+
}
68+
var aliased = ['-h', 'hello'];
69+
var regular = ['--herp', 'hello'];
70+
var opts = {
71+
default: { 'h': 'bar' },
72+
alias: { 'h': 'herp' },
73+
unknown: unknownFn
74+
};
75+
var aliasedArgv = parse(aliased, opts);
76+
var propertyArgv = parse(regular, opts);
7777

78-
t.same(unknown, []);
79-
t.end();
80-
unknownFn(); // exercise fn for 100% coverage
78+
t.same(unknown, []);
79+
t.end();
80+
unknownFn(); // exercise fn for 100% coverage
8181
});
8282

8383
test('value following -- is not unknown', function (t) {
84-
var unknown = [];
85-
function unknownFn(arg) {
86-
unknown.push(arg);
87-
return false;
88-
}
89-
var aliased = [ '--bad', '--', 'good', 'arg' ];
90-
var opts = {
91-
'--': true,
92-
unknown: unknownFn
93-
};
94-
var argv = parse(aliased, opts);
84+
var unknown = [];
85+
function unknownFn(arg) {
86+
unknown.push(arg);
87+
return false;
88+
}
89+
var aliased = ['--bad', '--', 'good', 'arg'];
90+
var opts = {
91+
'--': true,
92+
unknown: unknownFn
93+
};
94+
var argv = parse(aliased, opts);
9595

96-
t.same(unknown, ['--bad']);
97-
t.same(argv, {
98-
'--': ['good', 'arg'],
99-
'_': []
100-
})
101-
t.end();
96+
t.same(unknown, ['--bad']);
97+
t.same(argv, {
98+
'--': ['good', 'arg'],
99+
'_': []
100+
})
101+
t.end();
102102
});

‎test/whitespace.js

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
var parse = require('../');
22
var test = require('tape');
33

4-
test('whitespace should be whitespace' , function (t) {
5-
t.plan(1);
6-
var x = parse([ '-x', '\t' ]).x;
7-
t.equal(x, '\t');
4+
test('whitespace should be whitespace', function (t) {
5+
t.plan(1);
6+
var x = parse(['-x', '\t']).x;
7+
t.equal(x, '\t');
88
});

0 commit comments

Comments
 (0)
Please sign in to comment.