2016-11-29 20:14:10 +03:00
|
|
|
#!/usr/bin/env node
|
2017-01-18 01:16:40 +03:00
|
|
|
|
2017-01-10 20:18:22 +03:00
|
|
|
"use strict";
|
2017-01-28 18:50:22 +03:00
|
|
|
|
2016-11-29 20:14:10 +03:00
|
|
|
const fs = require("fs");
|
2017-01-11 18:57:16 +03:00
|
|
|
const getStdin = require("get-stdin");
|
2017-01-23 18:37:57 +03:00
|
|
|
const glob = require("glob");
|
2017-02-07 22:03:48 +03:00
|
|
|
const chalk = require("chalk");
|
2016-12-31 07:01:07 +03:00
|
|
|
const minimist = require("minimist");
|
2017-02-15 00:44:14 +03:00
|
|
|
const readline = require("readline");
|
2017-01-22 03:42:13 +03:00
|
|
|
const prettier = require("../index");
|
2017-05-09 04:16:35 +03:00
|
|
|
const cleanAST = require('../src/clean-ast.js').cleanAST;
|
2016-11-29 20:14:10 +03:00
|
|
|
|
2016-12-31 07:01:07 +03:00
|
|
|
const argv = minimist(process.argv.slice(2), {
|
2017-01-13 23:03:53 +03:00
|
|
|
boolean: [
|
|
|
|
"write",
|
|
|
|
"stdin",
|
2017-04-07 05:49:37 +03:00
|
|
|
"use-tabs",
|
2017-04-13 04:51:08 +03:00
|
|
|
"semi",
|
2017-01-13 23:03:53 +03:00
|
|
|
"single-quote",
|
2017-01-22 03:48:18 +03:00
|
|
|
"bracket-spacing",
|
2017-02-13 20:57:05 +03:00
|
|
|
"jsx-bracket-same-line",
|
2017-01-24 00:29:57 +03:00
|
|
|
// The supports-color package (a sub sub dependency) looks directly at
|
|
|
|
// `process.argv` for `--no-color` and such-like options. The reason it is
|
|
|
|
// listed here is to avoid "Ignored unknown option: --no-color" warnings.
|
|
|
|
// See https://github.com/chalk/supports-color/#info for more information.
|
2017-01-23 20:10:51 +03:00
|
|
|
"color",
|
2017-03-03 06:47:36 +03:00
|
|
|
"list-different",
|
2017-01-26 21:13:32 +03:00
|
|
|
"help",
|
2017-01-20 01:35:12 +03:00
|
|
|
"version",
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
"debug-print-doc",
|
2017-02-07 18:04:44 +03:00
|
|
|
"debug-check",
|
2017-01-20 01:35:12 +03:00
|
|
|
// Deprecated in 0.0.10
|
|
|
|
"flow-parser"
|
|
|
|
],
|
2017-02-18 06:44:55 +03:00
|
|
|
string: ["print-width", "tab-width", "parser", "trailing-comma"],
|
2017-04-13 20:18:35 +03:00
|
|
|
default: { semi: true, color: true, "bracket-spacing": true, parser: "babylon" },
|
2017-03-03 06:47:36 +03:00
|
|
|
alias: { help: "h", version: "v", "list-different": "l" },
|
2017-01-21 20:11:34 +03:00
|
|
|
unknown: param => {
|
|
|
|
if (param.startsWith("-")) {
|
|
|
|
console.warn("Ignored unknown option: " + param + "\n");
|
2017-01-26 21:13:32 +03:00
|
|
|
return false;
|
2017-01-21 20:11:34 +03:00
|
|
|
}
|
|
|
|
}
|
2016-12-31 07:01:07 +03:00
|
|
|
});
|
|
|
|
|
2017-01-18 23:45:44 +03:00
|
|
|
if (argv["version"]) {
|
2017-01-22 03:42:13 +03:00
|
|
|
console.log(prettier.version);
|
2017-01-18 23:45:44 +03:00
|
|
|
process.exit(0);
|
|
|
|
}
|
|
|
|
|
2017-01-23 18:37:57 +03:00
|
|
|
const filepatterns = argv["_"];
|
2017-01-10 23:45:04 +03:00
|
|
|
const write = argv["write"];
|
2017-02-23 20:57:51 +03:00
|
|
|
const stdin = argv["stdin"] || (!filepatterns.length && !process.stdin.isTTY);
|
2016-11-29 20:14:10 +03:00
|
|
|
|
2017-05-09 12:51:04 +03:00
|
|
|
if (write && argv["debug-check"]) {
|
|
|
|
console.error("Cannot use --write and --debug-check together.");
|
|
|
|
process.exit(1);
|
|
|
|
}
|
|
|
|
|
2017-01-26 21:13:32 +03:00
|
|
|
function getParserOption() {
|
|
|
|
const optionName = "parser";
|
|
|
|
const value = argv[optionName];
|
|
|
|
|
|
|
|
if (value === undefined) {
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2017-01-20 01:35:12 +03:00
|
|
|
// For backward compatibility. Deprecated in 0.0.10
|
|
|
|
if (argv["flow-parser"]) {
|
2017-01-21 20:23:29 +03:00
|
|
|
console.warn("`--flow-parser` is deprecated. Use `--parser flow` instead.");
|
2017-01-20 01:35:12 +03:00
|
|
|
return "flow";
|
|
|
|
}
|
|
|
|
|
2017-04-18 19:42:03 +03:00
|
|
|
if (value === "flow" || value === "babylon" || value === "typescript") {
|
2017-01-26 21:13:32 +03:00
|
|
|
return value;
|
2017-01-20 01:35:12 +03:00
|
|
|
}
|
|
|
|
|
2017-01-26 21:13:32 +03:00
|
|
|
console.warn(
|
|
|
|
"Ignoring unknown --" +
|
|
|
|
optionName +
|
|
|
|
' value, falling back to "babylon":\n' +
|
|
|
|
' Expected "flow" or "babylon", but received: ' +
|
|
|
|
JSON.stringify(value)
|
|
|
|
);
|
|
|
|
|
2017-01-20 01:35:12 +03:00
|
|
|
return "babylon";
|
|
|
|
}
|
|
|
|
|
2017-01-26 21:13:32 +03:00
|
|
|
function getIntOption(optionName) {
|
|
|
|
const value = argv[optionName];
|
|
|
|
|
|
|
|
if (value === undefined) {
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (/^\d+$/.test(value)) {
|
|
|
|
return Number(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
console.error(
|
|
|
|
"Invalid --" +
|
|
|
|
optionName +
|
|
|
|
" value. Expected an integer, but received: " +
|
|
|
|
JSON.stringify(value)
|
|
|
|
);
|
|
|
|
process.exit(1);
|
|
|
|
}
|
|
|
|
|
2017-02-18 06:44:55 +03:00
|
|
|
function getTrailingComma() {
|
|
|
|
switch (argv["trailing-comma"]) {
|
|
|
|
case undefined:
|
|
|
|
case "none":
|
|
|
|
return "none";
|
|
|
|
case "":
|
2017-02-23 20:57:51 +03:00
|
|
|
console.warn(
|
|
|
|
"Warning: `--trailing-comma` was used without an argument. This is deprecated. " +
|
|
|
|
'Specify "none", "es5", or "all".'
|
|
|
|
);
|
2017-02-18 06:44:55 +03:00
|
|
|
case "es5":
|
|
|
|
return "es5";
|
|
|
|
case "all":
|
|
|
|
return "all";
|
|
|
|
default:
|
|
|
|
throw new Error("Invalid option for --trailing-comma");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
const options = {
|
2017-04-07 05:49:37 +03:00
|
|
|
useTabs: argv["use-tabs"],
|
2017-04-13 04:51:08 +03:00
|
|
|
semi: argv["semi"],
|
2017-01-26 21:13:32 +03:00
|
|
|
printWidth: getIntOption("print-width"),
|
|
|
|
tabWidth: getIntOption("tab-width"),
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
bracketSpacing: argv["bracket-spacing"],
|
|
|
|
singleQuote: argv["single-quote"],
|
2017-02-18 06:44:55 +03:00
|
|
|
jsxBracketSameLine: argv["jsx-bracket-same-line"],
|
|
|
|
trailingComma: getTrailingComma(),
|
|
|
|
parser: getParserOption()
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
};
|
|
|
|
|
2017-01-11 18:57:16 +03:00
|
|
|
function format(input) {
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
if (argv["debug-print-doc"]) {
|
2017-01-22 03:42:13 +03:00
|
|
|
const doc = prettier.__debug.printToDoc(input, options);
|
|
|
|
return prettier.__debug.formatDoc(doc);
|
Add debugging support for doc IR (#347)
This PR adds two things:
`--debug-print-doc` command that prints the formatted doc
```js
echo "<div><</div>" | ./bin/prettier.js --stdin --debug-print-doc
[
groupConditional(
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
[
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
"<",
"</",
"div",
">"
]),
group([
group([ "<", "div", group([ indent(2, []), softline() ]), ">" ]),
indent(2, groupBreak([ hardline(), "<" ])),
hardline(),
"</",
"div",
">"
])
]
),
";",
hardline()
];
```
The ability to view the IR in real time on the browser display:
![image](https://cloud.githubusercontent.com/assets/197597/22134741/4f172f20-de7e-11e6-84bc-5f813976dc19.png)
The way it works is pretty cool, we take the doc IR and print a valid JavaScript string out of it, that we then send to prettier in order to make it look good :)
2017-01-20 20:54:32 +03:00
|
|
|
}
|
2017-02-07 18:04:44 +03:00
|
|
|
|
|
|
|
if (argv["debug-check"]) {
|
2017-04-22 02:09:33 +03:00
|
|
|
function diff(a, b) {
|
|
|
|
return require("diff")
|
|
|
|
.createTwoFilesPatch("", "", a, b, "", "", { context: 2 });
|
|
|
|
}
|
|
|
|
|
2017-02-07 18:04:44 +03:00
|
|
|
const pp = prettier.format(input, options);
|
|
|
|
const pppp = prettier.format(pp, options);
|
|
|
|
if (pp !== pppp) {
|
2017-04-22 02:09:33 +03:00
|
|
|
process.stdout.write("\n");
|
|
|
|
console.error('prettier(input) !== prettier(prettier(input))');
|
|
|
|
console.error(diff(pp, pppp));
|
2017-05-09 12:51:04 +03:00
|
|
|
process.exitCode = 2;
|
2017-04-22 02:09:33 +03:00
|
|
|
} else {
|
|
|
|
const ast = cleanAST(prettier.__debug.parse(input, options));
|
|
|
|
const past = cleanAST(prettier.__debug.parse(pp, options));
|
|
|
|
|
|
|
|
if (ast !== past) {
|
|
|
|
process.stdout.write("\n");
|
|
|
|
console.error('ast(input) !== ast(prettier(input))');
|
|
|
|
console.error(diff(ast, past));
|
|
|
|
console.error(diff(input, pp));
|
2017-05-09 12:51:04 +03:00
|
|
|
process.exitCode = 2;
|
2017-04-22 02:09:33 +03:00
|
|
|
}
|
2017-02-07 18:04:44 +03:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-01-22 03:42:13 +03:00
|
|
|
return prettier.format(input, options);
|
2017-01-11 18:57:16 +03:00
|
|
|
}
|
2017-01-10 07:03:35 +03:00
|
|
|
|
2017-01-26 21:13:32 +03:00
|
|
|
function handleError(filename, e) {
|
|
|
|
const isParseError = Boolean(e && e.loc);
|
|
|
|
const isValidationError = /Validation Error/.test(e && e.message);
|
|
|
|
|
|
|
|
// For parse errors and validation errors, we only want to show the error
|
|
|
|
// message formatted in a nice way. `String(e)` takes care of that. Other
|
|
|
|
// (unexpected) errors are passed as-is as a separate argument to
|
|
|
|
// `console.error`. That includes the stack trace (if any), and shows a nice
|
|
|
|
// `util.inspect` of throws things that aren't `Error` objects. (The Flow
|
|
|
|
// parser has mistakenly thrown arrays sometimes.)
|
|
|
|
if (isParseError) {
|
|
|
|
console.error(filename + ": " + String(e));
|
|
|
|
} else if (isValidationError) {
|
|
|
|
console.error(String(e));
|
|
|
|
// If validation fails for one file, it will fail for all of them.
|
|
|
|
process.exit(1);
|
|
|
|
} else {
|
|
|
|
console.error(filename + ":", e);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't exit the process if one file failed
|
|
|
|
process.exitCode = 2;
|
|
|
|
}
|
|
|
|
|
2017-02-23 20:57:51 +03:00
|
|
|
if (argv["help"] || (!filepatterns.length && !stdin)) {
|
2017-02-18 06:44:55 +03:00
|
|
|
console.log(
|
|
|
|
"Usage: prettier [opts] [filename ...]\n\n" +
|
|
|
|
"Available options:\n" +
|
|
|
|
" --write Edit the file in-place. (Beware!)\n" +
|
2017-04-19 19:04:47 +03:00
|
|
|
" --list-different or -l Print filenames of files that are different from Prettier formatting.\n" +
|
2017-02-18 06:44:55 +03:00
|
|
|
" --stdin Read input from stdin.\n" +
|
|
|
|
" --print-width <int> Specify the length of line that the printer will wrap on. Defaults to 80.\n" +
|
|
|
|
" --tab-width <int> Specify the number of spaces per indentation-level. Defaults to 2.\n" +
|
2017-04-19 19:04:47 +03:00
|
|
|
" --use-tabs Indent lines with tabs instead of spaces.\n" +
|
|
|
|
" --no-semi Do not print semicolons, except at the beginning of lines which may need them.\n" +
|
|
|
|
" --single-quote Use single quotes instead of double quotes.\n" +
|
|
|
|
" --no-bracket-spacing Do not print spaces between brackets.\n" +
|
|
|
|
" --jsx-bracket-same-line Put > on the last line instead of at a new line.\n" +
|
2017-02-18 06:44:55 +03:00
|
|
|
" --trailing-comma <none|es5|all>\n" +
|
|
|
|
" Print trailing commas wherever possible. Defaults to none.\n" +
|
|
|
|
" --parser <flow|babylon> Specify which parse to use. Defaults to babylon.\n" +
|
2017-04-19 19:04:47 +03:00
|
|
|
" --no-color Do not colorize error messages.\n" +
|
|
|
|
" --version or -v Print Prettier version.\n" +
|
|
|
|
"\n"
|
2017-02-18 06:44:55 +03:00
|
|
|
);
|
|
|
|
process.exit(argv["help"] ? 0 : 1);
|
|
|
|
}
|
|
|
|
|
2017-01-11 18:57:16 +03:00
|
|
|
if (stdin) {
|
|
|
|
getStdin().then(input => {
|
2017-01-11 09:10:00 +03:00
|
|
|
try {
|
2017-01-24 00:10:26 +03:00
|
|
|
// Don't use `console.log` here since it adds an extra newline at the end.
|
|
|
|
process.stdout.write(format(input));
|
2017-01-11 09:10:00 +03:00
|
|
|
} catch (e) {
|
2017-01-26 21:13:32 +03:00
|
|
|
handleError("stdin", e);
|
2017-01-11 09:10:00 +03:00
|
|
|
return;
|
|
|
|
}
|
2017-01-11 18:57:16 +03:00
|
|
|
});
|
|
|
|
} else {
|
2017-01-23 18:37:57 +03:00
|
|
|
eachFilename(filepatterns, filename => {
|
2017-03-20 20:14:33 +03:00
|
|
|
if (write || argv["debug-check"]) {
|
|
|
|
// Don't use `console.log` here since we need to replace this line.
|
|
|
|
process.stdout.write(filename);
|
|
|
|
}
|
2016-12-31 07:01:07 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
let input;
|
|
|
|
try {
|
|
|
|
input = fs.readFileSync(filename, "utf8");
|
2017-04-12 20:16:11 +03:00
|
|
|
} catch (e) {
|
2017-03-20 20:14:33 +03:00
|
|
|
// Add newline to split errors from filename line.
|
|
|
|
process.stdout.write("\n");
|
|
|
|
|
2017-04-14 01:49:53 +03:00
|
|
|
console.error("Unable to read file: " + filename + "\n" + e);
|
2017-03-20 20:14:33 +03:00
|
|
|
// Don't exit the process if one file failed
|
|
|
|
process.exitCode = 2;
|
|
|
|
return;
|
|
|
|
}
|
2017-02-07 22:03:48 +03:00
|
|
|
|
2017-04-03 19:54:10 +03:00
|
|
|
if (argv["list-different"]) {
|
|
|
|
if (!prettier.check(input, options)) {
|
|
|
|
console.log(filename);
|
|
|
|
process.exitCode = 1;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
const start = Date.now();
|
2017-01-11 18:57:16 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
let output;
|
2017-02-07 22:03:48 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
try {
|
|
|
|
output = format(input);
|
|
|
|
} catch (e) {
|
|
|
|
// Add newline to split errors from filename line.
|
|
|
|
process.stdout.write("\n");
|
2017-02-07 22:03:48 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
handleError(filename, e);
|
|
|
|
return;
|
|
|
|
}
|
2017-02-07 22:03:48 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
if (write) {
|
|
|
|
// Remove previously printed filename to log it with duration.
|
|
|
|
readline.clearLine(process.stdout, 0);
|
|
|
|
readline.cursorTo(process.stdout, 0, null);
|
2017-01-11 18:57:16 +03:00
|
|
|
|
2017-03-20 20:14:33 +03:00
|
|
|
// Don't write the file if it won't change in order not to invalidate
|
|
|
|
// mtime based caches.
|
|
|
|
if (output === input) {
|
|
|
|
console.log(chalk.grey("%s %dms"), filename, Date.now() - start);
|
2017-01-11 18:57:16 +03:00
|
|
|
} else {
|
2017-03-20 20:14:33 +03:00
|
|
|
console.log("%s %dms", filename, Date.now() - start);
|
|
|
|
|
2017-04-16 00:06:20 +03:00
|
|
|
try {
|
|
|
|
fs.writeFileSync(filename, output, "utf8");
|
|
|
|
} catch (err) {
|
|
|
|
console.error("Unable to write file: " + filename + "\n" + err);
|
|
|
|
// Don't exit the process if one file failed
|
|
|
|
process.exitCode = 2;
|
|
|
|
}
|
2017-01-11 18:57:16 +03:00
|
|
|
}
|
2017-03-20 20:14:33 +03:00
|
|
|
} else if (argv["debug-check"]) {
|
|
|
|
process.stdout.write("\n");
|
|
|
|
if (output) {
|
|
|
|
console.log(output);
|
2017-05-09 12:51:04 +03:00
|
|
|
} else {
|
|
|
|
process.exitCode = 2;
|
2017-03-20 20:14:33 +03:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Don't use `console.log` here since it adds an extra newline at the end.
|
|
|
|
process.stdout.write(output);
|
|
|
|
}
|
2017-01-10 23:45:04 +03:00
|
|
|
});
|
2017-01-11 18:57:16 +03:00
|
|
|
}
|
2017-01-23 18:37:57 +03:00
|
|
|
|
|
|
|
function eachFilename(patterns, callback) {
|
|
|
|
patterns.forEach(pattern => {
|
2017-04-17 07:12:49 +03:00
|
|
|
if (!glob.hasMagic(pattern)) {
|
|
|
|
callback(pattern);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-01-23 18:37:57 +03:00
|
|
|
glob(pattern, (err, filenames) => {
|
|
|
|
if (err) {
|
|
|
|
console.error("Unable to expand glob pattern: " + pattern + "\n" + err);
|
|
|
|
// Don't exit the process if one pattern failed
|
|
|
|
process.exitCode = 2;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
filenames.forEach(filename => {
|
|
|
|
callback(filename);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|