// Formats JSON files with Prettier and with tidy, under several option sets, and compares the outputs. Each file is // formatted with the parser that Prettier infers from its name, and with each of the four JSON parsers. Both // rejecting a file counts as the same. The files are those of the repos in `--oss`, and the inputs of JSONTestSuite, // valid or not. Prettier overflows its stack on a value nested about 2,000 deep, which tidy formats: those runs are // counted apart. // // bun tests/oracle/json.ts [filter] [--show=n] [--oss=] import { $ } from "bun"; import { createHash } from "node:crypto"; import { homedir } from "node:os"; import { join } from "node:path"; import { parsing, transform } from "json-test-suite"; import * as prettier from "prettier"; import { format, type FormatOptions } from "../../crates/tidy_napi/index.js"; let args = Bun.argv.slice(2).filter((arg) => !arg.startsWith("--")); let option = (name: string) => Bun.argv.find((arg) => arg.startsWith(`--${name}=`))?.slice(name.length + 3); let show = Number(option("show") ?? 5); let oss = option("oss") ?? join(homedir(), "repos", "oss"); let filter = args[0] ?? ""; type Set = { name: string; parser?: string; prettier: Record; tidy: FormatOptions; }; /** * Option sets: Prettier's names, and tidy's for the same. Without a parser, it * is the one Prettier infers. */ let sets: Set[] = [ { name: "default", prettier: {}, tidy: {} }, { name: "json", parser: "json", prettier: {}, tidy: {} }, { name: "jsonc", parser: "jsonc", prettier: {}, tidy: {} }, { name: "json5", parser: "json5", prettier: {}, tidy: {} }, { name: "json-stringify", parser: "json-stringify", prettier: {}, tidy: {} }, { name: "jsonc, no trailing commas, width 40, tabs", parser: "jsonc", prettier: { trailingComma: "none", printWidth: 40, useTabs: true }, tidy: { trailingComma: false, width: 40, tabs: true }, }, { name: "json5, consistent, single quotes", parser: "json5", prettier: { quoteProps: "consistent", singleQuote: true }, tidy: { quote: "single", json: { quoteProps: "consistent" } }, }, { name: "json5, preserve", parser: "json5", prettier: { quoteProps: "preserve" }, tidy: { json: { quoteProps: "preserve" } }, }, { name: "json, collapse, no bracket spacing", parser: "json", prettier: { objectWrap: "collapse", bracketSpacing: false }, tidy: { json: { objectWrap: "collapse", bracketSpacing: false } }, }, ]; /** Prettier's `getLanguageByFileName`, for its JSON languages. */ let languages = (await prettier.getSupportInfo()).languages.filter((it) => it.parsers[0]?.startsWith("json"), ); function inferParser(path: string) { let name = path.slice(path.lastIndexOf("/") + 1).toLowerCase(); let language = languages.find((it) => it.filenames?.some((file) => file.toLowerCase() === name), ) ?? languages.find((it) => it.extensions?.some((extension) => name.endsWith(extension)), ); return language?.parsers[0]; } let listed = await $`fd --type f --no-ignore --exclude node_modules --exclude target --exclude .git . ${oss}` .nothrow() .quiet() .text(); let seen = new Set(); let files: { path: string; source: string; parser: string }[] = []; for (let path of listed.split("\n").filter(Boolean)) { let parser = inferParser(path); if (!parser) continue; let source = await Bun.file(path) .text() .catch(() => undefined); if (source === undefined || source.length > 1_000_000) continue; let hash = createHash("sha1").update(source).digest("hex"); if (seen.has(hash)) continue; seen.add(hash); files.push({ path, source, parser }); } for (let { name, input } of [...parsing, ...transform]) { if (name.includes("utf16") || name.includes("UTF-16")) continue; files.push({ path: join(oss, "json-test-suite", name), source: input, parser: "json", }); } let passed = 0; let overflowed = 0; let total = 0; let failed: { name: string; expected: string; actual: string }[] = []; let perSet = new Map(); for (let set of sets) { for (let file of files) { let name = `${set.name}: ${file.path.slice(oss.length + 1)}`; if (filter && !name.includes(filter)) continue; total++; let parser = set.parser ?? file.parser; let expected: string; try { expected = await prettier.format(file.source, { parser, ...set.prettier, }); } catch (error) { if (error instanceof RangeError) { overflowed++; total--; continue; } expected = "!error"; } let actual: string; try { actual = format(file.source, { parser: parser as FormatOptions["parser"], ...set.tidy, }); } catch (error) { actual = `!error ${(error as Error).message}`; } let same = expected === actual || (expected === "!error" && actual.startsWith("!error")); if (same) passed++; else { failed.push({ name, expected, actual }); perSet.set(set.name, (perSet.get(set.name) ?? 0) + 1); } } } for (let failure of failed.slice(0, show)) { console.log(`\n✗ ${failure.name}`); await Bun.write("/tmp/tidy-expected", failure.expected); await Bun.write("/tmp/tidy-actual", failure.actual); let diff = await $`diff -u /tmp/tidy-expected /tmp/tidy-actual` .nothrow() .text(); console.log(diff.split("\n").slice(2, 40).join("\n")); } for (let [name, count] of perSet) console.log(` ${name}: ${count} different`); if (overflowed) console.log(` ${overflowed} runs left out: Prettier overflowed its stack`); console.log( `\njson: ${passed}/${total} same (${((passed / total) * 100).toFixed(1)}%), ${files.length} files`, ); await Bun.write( join(import.meta.dir, "../../target/conformance-json.txt"), failed.map((failure) => failure.name).join("\n"), );