mmdfmt 0.0.0 → 0.2.0

package/lib/cli.mjs

@@ -0,0 +1,433 @@
+#!/usr/bin/env node
+import { a as kindOf, i as formatFile, n as endingsInWords } from "./format-file-DSbEElSV.mjs";
+import path from "node:path";
+import { getFileInfo } from "prettier";
+import { text } from "node:stream/consumers";
+import { readFile, stat, writeFile } from "node:fs/promises";
+import { styleText } from "node:util";
+import { cli, define, isArgsValidationError } from "gunshi";
+import { convertPathToPattern, glob } from "tinyglobby";
+//#region src/broken-pipe.ts
+/**
+* The listener of the errors of standard output. When the reader of standard
+* output goes away, as `head` does once it has its lines, writing fails with
+* `EPIPE`. Other command-line tools then end without a word; so does this
+* tool, and it finishes the run, so that `--write` still rewrites every file
+* and the exit code still tells the result (README, Usage). Any other error is
+* thrown, as Node.js throws it when the stream has no listener.
+*/
+function ignoreBrokenPipe(error) {
+	if (error.code !== "EPIPE") throw error;
+}
+//#endregion
+//#region package.json
+var version = "0.2.0";
+var description = "Formatter for Mermaid diagrams in .mmd files and in Markdown code blocks, which changes nothing else, as a command and as a function";
+//#endregion
+//#region src/patterns.ts
+/**
+* The directories whose files are skipped, those that Prettier's CLI skips
+* (README, Excluding files).
+*/
+const skippedDirectories = [
+	"node_modules",
+	".git",
+	".hg",
+	".jj",
+	".sl",
+	".svn"
+];
+/** The globs of the files under the skipped directories. */
+const skippedDirectoryGlobs = skippedDirectories.map((directory) => `**/${directory}/**`);
+/**
+* Selects the files that the patterns name, of those the tool formats, as
+* Prettier's CLI reads the patterns (README, Patterns). A pattern that names a
+* path in a skipped directory, a file, a directory, or a glob, is skipped. A
+* pattern is then first the path of a file or of a directory. Otherwise, a
+* pattern that starts with `!` excludes the files that the glob after it
+* matches from what every other pattern selects, and any other pattern is a
+* glob.
+*/
+async function selectFiles(patterns, cwd) {
+	const selecting = [];
+	const excluding = [];
+	const skipped = [];
+	for (const pattern of patterns) {
+		const target = path.resolve(cwd, pattern);
+		if (passesSkippedDirectory(target, cwd)) {
+			skipped.push(pattern);
+			continue;
+		}
+		const stats = await stat(target).catch(() => void 0);
+		if (stats?.isFile()) selecting.push({
+			kind: "file",
+			text: pattern,
+			path: target
+		});
+		else if (stats?.isDirectory()) selecting.push({
+			kind: "directory",
+			text: pattern,
+			path: target
+		});
+		else if (pattern.startsWith("!")) excluding.push(globOf(pattern.slice(1)));
+		else selecting.push({
+			kind: "glob",
+			text: pattern
+		});
+	}
+	const files = /* @__PURE__ */ new Map();
+	const unmatched = [];
+	const excluded = [];
+	for (const pattern of selecting) {
+		if (pattern.kind === "file" && await isExcluded(pattern.path, cwd, excluding)) {
+			excluded.push(pattern.text);
+			continue;
+		}
+		const selected = [];
+		for (const file of (await filesOf(pattern, cwd, excluding)).sort()) {
+			const kind = kindOf(file);
+			if (kind !== void 0) selected.push({
+				path: file,
+				kind
+			});
+		}
+		if (selected.length === 0) unmatched.push(pattern.text);
+		for (const file of selected) if (!files.has(file.path)) files.set(file.path, file);
+	}
+	return {
+		files: [...files.values()],
+		noSelectingPattern: selecting.length === 0,
+		skipped,
+		unmatched,
+		excluded
+	};
+}
+/**
+* A pattern as a glob. On Windows, Prettier's CLI reads a `\` of a glob as
+* `/`, the separator of globs; so does this (README, Patterns).
+*/
+function globOf(pattern) {
+	return process.platform === "win32" ? pattern.replaceAll("\\", "/") : pattern;
+}
+/**
+* Whether the globs of the excluding patterns match a file, given by its
+* absolute path. As in Prettier's CLI, they are matched against its path from
+* `cwd`.
+*/
+async function isExcluded(file, cwd, excluding) {
+	return (await globFiles(convertPathToPattern(path.relative(cwd, file)), cwd, excluding)).length === 0;
+}
+/**
+* The files that a pattern names, as absolute paths, apart from those that the
+* globs of the excluding patterns match. The path of a file names the file
+* wherever it is; a directory or a glob names no file under a skipped
+* directory, as Prettier's CLI does not look into one.
+*/
+async function filesOf(pattern, cwd, excluding) {
+	if (pattern.kind === "file") return [pattern.path];
+	const ignore = [...skippedDirectoryGlobs, ...excluding];
+	return (pattern.kind === "directory" ? await globFiles(`${convertPathToPattern(path.relative(cwd, pattern.path) || ".")}/**/*`, cwd, ignore) : await globFiles(globOf(pattern.text), cwd, ignore)).filter((file) => !isUnderSkippedDirectory(file, cwd));
+}
+/**
+* The files that a glob matches from `cwd`, as absolute paths, apart from
+* those that the globs of `ignore` match. Like Prettier's CLI, it matches names
+* that start with a dot and follows no symbolic link.
+*/
+async function globFiles(pattern, cwd, ignore) {
+	return (await glob(pattern, {
+		cwd,
+		absolute: true,
+		dot: true,
+		expandDirectories: false,
+		followSymbolicLinks: false,
+		ignore: [...ignore]
+	})).map((file) => path.resolve(file));
+}
+/**
+* Whether a path, taken from `cwd`, is one of the skipped directories or passes
+* through one, as Prettier's CLI decides it for a pattern.
+*/
+function passesSkippedDirectory(target, cwd) {
+	return path.relative(cwd, target).split(path.sep).some((name) => skippedDirectories.includes(name));
+}
+/** Whether a file is under one of the skipped directories of `cwd`. */
+function isUnderSkippedDirectory(file, cwd) {
+	return passesSkippedDirectory(path.dirname(file), cwd);
+}
+/**
+* Whether a file is skipped: it is under one of the skipped directories, or
+* the `.gitignore` of the current directory lists it (README, Excluding files).
+*
+* Unlike Prettier's CLI, the tool does not read `.prettierignore`. It is used
+* where Prettier does not format the Markdown, and the `.prettierignore` there
+* often lists the Markdown files: reading it would leave their diagrams
+* unformatted without a word. If users ask for a way to keep files from this
+* tool alone, other than a pattern that starts with `!`, read a file of its
+* own, such as `.mmdfmtignore`, not `.prettierignore`.
+*/
+async function isSkipped(file, cwd) {
+	if (isUnderSkippedDirectory(file, cwd)) return true;
+	const { ignored } = await getFileInfo(file, {
+		ignorePath: path.join(cwd, ".gitignore"),
+		resolveConfig: false
+	});
+	return ignored;
+}
+//#endregion
+//#region src/main.ts
+/** The exit codes (README, Errors and exit codes). */
+const exitCodes = {
+	ok: 0,
+	changed: 1,
+	error: 2
+};
+/** The examples in the usage, one on a line (README, Usage). */
+const examples = `mmdfmt --write "**/*.{md,mmd,mermaid}"
+mmdfmt --check "**/*.{md,mmd,mermaid}"
+mmdfmt --stdin-filepath diagram.mmd < diagram.mmd`;
+/** Runs the tool with its arguments, and returns the exit code (README, Usage). */
+async function main(args, io) {
+	let code = exitCodes.ok;
+	const command = define({
+		toKebab: true,
+		args: {
+			write: {
+				type: "boolean",
+				short: "w",
+				negatable: true,
+				description: "Rewrite the files that change, and list each file with its time"
+			},
+			check: {
+				type: "boolean",
+				short: "c",
+				negatable: true,
+				description: "Check whether the files are formatted, and print a summary and the files that are not",
+				conflicts: ["listDifferent"]
+			},
+			listDifferent: {
+				type: "boolean",
+				short: "l",
+				negatable: true,
+				description: "List the files that --write would change",
+				conflicts: ["check"]
+			},
+			stdinFilepath: {
+				type: "string",
+				description: "Format standard input as the file at this path, and write the result to standard output"
+			},
+			patterns: {
+				type: "positional",
+				multiple: true,
+				required: false,
+				description: "The files, directories, or globs of the files to format"
+			}
+		},
+		examples,
+		/** Runs the mode that the arguments select, and keeps its exit code. */
+		async run(ctx) {
+			if (args.length === 0) {
+				const usage = await ctx.env.renderUsage?.(ctx);
+				io.stderr(usage ?? "");
+				code = exitCodes.error;
+				return;
+			}
+			const { write, check, listDifferent, stdinFilepath } = ctx.values;
+			const patterns = [...ctx.values.patterns ?? [], ...ctx.rest];
+			if (stdinFilepath !== void 0) code = patterns.length > 0 ? argumentError(io, ["--stdin-filepath takes no patterns"]) : await formatStandardInput(stdinFilepath, {
+				write: Boolean(write),
+				listsDifference: Boolean(check) || Boolean(listDifferent)
+			}, io);
+			else if (ctx.explicit.stdinFilepath) code = argumentError(io, ["--stdin-filepath needs a path"]);
+			else if (patterns.length === 0) code = argumentError(io, ["no patterns of the files to format"]);
+			else if (!write && !check && !listDifferent) code = argumentError(io, ["give --write, --check, or --list-different with the patterns"]);
+			else code = await formatFiles(patterns, {
+				write: Boolean(write),
+				check: Boolean(check),
+				listDifferent: Boolean(listDifferent)
+			}, io);
+		}
+	});
+	try {
+		const printed = await cli([...args], command, {
+			name: "mmdfmt",
+			version,
+			description,
+			strict: true,
+			usageSilent: true
+		});
+		if (printed !== void 0) io.stdout(printed.endsWith("\n") ? printed : `${printed}\n`);
+	} catch (error) {
+		if (error instanceof AggregateError && error.errors.every(isArgsValidationError)) return argumentError(io, error.errors.map(messageOf));
+		throw error;
+	}
+	return code;
+}
+/**
+* Formats the files that the patterns select, following Prettier's counts
+* and reports for `write`, `check`, and `listDifferent`.
+*/
+async function formatFiles(patterns, mode, io) {
+	if (mode.check) io.stdout("Checking formatting...\n");
+	const { files, noSelectingPattern, skipped, unmatched, excluded } = await selectFiles(patterns, io.cwd);
+	let failed = noSelectingPattern || unmatched.length > 0 || excluded.length > 0;
+	let numberOfUnformattedFilesFound = 0;
+	let numberOfFilesWithError = 0;
+	if (noSelectingPattern) argumentError(io, [skipped.length > 0 ? "no patterns of the files to format; a pattern in node_modules or a directory of version control is skipped" : "no patterns of the files to format; a pattern that starts with ! only excludes files"]);
+	for (const pattern of unmatched) io.stderr(`mmdfmt: error: no file ending in ${endingsInWords} matches ${JSON.stringify(pattern)}\n`);
+	for (const pattern of excluded) io.stderr(`mmdfmt: error: a pattern that starts with ! excludes the file ${JSON.stringify(pattern)}\n`);
+	for (const file of files) {
+		const name = displayName(file.path, io.cwd);
+		let text, result;
+		try {
+			if (await isSkipped(file.path, io.cwd)) continue;
+			text = await readFile(file.path, "utf8");
+		} catch (error) {
+			io.stderr(`${name}: error: ${messageOf(error)}\n`);
+			failed = true;
+			continue;
+		}
+		const start = performance.now();
+		try {
+			result = await formatFile(text, file.path, file.kind, mode.write ? "output" : "input");
+			report(io, name, result.diagnostics);
+			if (result.diagnostics.some(isError)) {
+				failed = true;
+				numberOfFilesWithError += 1;
+				continue;
+			}
+		} catch (error) {
+			io.stderr(`${name}: error: ${messageOf(error)}\n`);
+			failed = true;
+			numberOfFilesWithError += 1;
+			continue;
+		}
+		const listsTimes = mode.write && !mode.check && !mode.listDifferent;
+		const time = `${Math.round(performance.now() - start)}ms`;
+		if (result.text === text) {
+			if (listsTimes) io.stdout(`${style(io.stdoutStream, "gray", name)} ${time} (unchanged)\n`);
+			continue;
+		}
+		if (mode.write) {
+			if (listsTimes) io.stdout(`${name} ${time}\n`);
+			try {
+				await writeFile(file.path, result.text);
+			} catch (error) {
+				io.stderr(`${name}: error: ${messageOf(error)}\n`);
+				failed = true;
+			}
+		}
+		if (mode.check) warn(io, name);
+		else if (mode.listDifferent) io.stdout(`${name}\n`);
+		numberOfUnformattedFilesFound += 1;
+	}
+	if (mode.check) {
+		if (numberOfFilesWithError > 0) {
+			const filesDescription = numberOfFilesWithError === 1 ? "the above file" : `${numberOfFilesWithError} files`;
+			io.stdout(`Error occurred when checking code style in ${filesDescription}.\n`);
+		} else if (numberOfUnformattedFilesFound === 0) io.stdout("All diagrams in the matched files use Prettier code style!\n");
+		else {
+			const filesDescription = numberOfUnformattedFilesFound === 1 ? "the above file" : `${numberOfUnformattedFilesFound} files`;
+			warn(io, mode.write ? `Code style issues fixed in ${filesDescription}.` : `Code style issues found in ${filesDescription}. Run mmdfmt with --write to fix.`);
+		}
+	}
+	if (failed) return exitCodes.error;
+	return numberOfUnformattedFilesFound > 0 && !mode.write ? exitCodes.changed : exitCodes.ok;
+}
+/**
+* Formats standard input as the file at `filepath`, and writes the result to
+* standard output. A skipped path gets its input back unchanged, and a
+* rejected diagram file gets nothing. With `listsDifference` (`--check` or
+* `--list-different`), the result is not written: `(stdin)` is listed when it
+* differs from the input, unless `write` is given too, as Prettier lists it.
+* `write` alone changes nothing: no file is written.
+*/
+async function formatStandardInput(filepath, mode, io) {
+	const file = path.resolve(io.cwd, filepath);
+	const kind = kindOf(file);
+	if (kind === void 0) {
+		io.stderr(`mmdfmt: error: the path of --stdin-filepath does not end in ${endingsInWords}: ${JSON.stringify(filepath)}\n`);
+		return exitCodes.error;
+	}
+	const text = await io.readStdin();
+	try {
+		if (await isSkipped(file, io.cwd)) {
+			io.stdout(text);
+			return exitCodes.ok;
+		}
+		const result = await formatFile(text, file, kind, mode.listsDifference ? "input" : "output");
+		report(io, filepath, result.diagnostics);
+		if (result.diagnostics.some(isError)) return exitCodes.error;
+		if (!mode.listsDifference) {
+			io.stdout(result.text);
+			return exitCodes.ok;
+		}
+		if (result.text === text || mode.write) return exitCodes.ok;
+		io.stdout("(stdin)\n");
+		return exitCodes.changed;
+	} catch (error) {
+		io.stderr(`${filepath}: error: ${messageOf(error)}\n`);
+		return exitCodes.error;
+	}
+}
+/**
+* Writes a warning of `--check` to standard error, as Prettier's logger
+* writes one: `[warn] ` before the text, with the word `warn` in yellow where
+* the stream shows colors.
+*/
+function warn(io, text) {
+	io.stderr(`[${style(io.stderrStream, "yellow", "warn")}] ${text}\n`);
+}
+/**
+* `text` in `color` where Node's `util.styleText` colors text for `stream`,
+* and as it is without a stream.
+*/
+function style(stream, color, text) {
+	return stream === void 0 ? text : styleText(color, text, { stream });
+}
+/**
+* The name of a file in what the tool prints: its path relative to `cwd`, with
+* `/` between its parts on every system, as Prettier's CLI writes the name of a
+* file (README, Usage). `pathOf` is `node:path` of the system the tool runs on;
+* a test gives `path.win32` or `path.posix`.
+*/
+function displayName(file, cwd, pathOf = path) {
+	return pathOf.relative(cwd, file).replaceAll(pathOf.sep, "/");
+}
+/** Writes the diagnostics of a file to standard error. */
+function report(io, name, diagnostics) {
+	for (const { severity, message, position } of diagnostics) io.stderr(`${name}:${position.line}:${position.column}: ${severity}: ${message}\n`);
+}
+/** Whether a diagnostic makes the run fail. */
+function isError(diagnostic) {
+	return diagnostic.severity === "error";
+}
+/** Reports wrong uses of the arguments, and returns 2 (README, Usage). */
+function argumentError(io, messages) {
+	for (const message of messages) io.stderr(`mmdfmt: error: ${message}\n`);
+	return exitCodes.error;
+}
+/** The message of a thrown value. */
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/cli.ts
+/** Reads standard input to its end, as UTF-8. */
+async function readStdin() {
+	return text(process.stdin.setEncoding("utf8"));
+}
+process.stdout.on("error", ignoreBrokenPipe);
+process.exitCode = await main(process.argv.slice(2), {
+	cwd: process.cwd(),
+	readStdin,
+	stdout: (output) => {
+		process.stdout.write(output);
+	},
+	stderr: (output) => {
+		process.stderr.write(output);
+	},
+	stdoutStream: process.stdout,
+	stderrStream: process.stderr
+});
+//#endregion
+export {};