Update Babel plugin tests (#20053)

scripts/update-babel-plugin-tests.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import dashify from "dashify";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { gfm as gfmSyntax } from "micromark-extension-gfm";
+import { outdent } from "outdent";
+
+const testDirectory = new URL(
+  "../tests/format/js/babel-plugins/",
+  import.meta.url,
+);
+const docUrl =
+  "https://raw.githubusercontent.com/babel/website/HEAD/docs/parser.md";
+const cacheFile = new URL("../.tmp/babel-parser-plugins.md", import.meta.url);
+
+async function getDoc() {
+  let stat;
+
+  try {
+    stat = await fs.stat(cacheFile);
+  } catch {
+    // No op
+  }
+
+  if (stat) {
+    if (Date.now() - stat.mtimeMs < /* 60 minutes */ 60 * 60 * 1000) {
+      return fs.readFile(cacheFile, "utf8");
+    }
+
+    await fs.rm(cacheFile);
+  }
+
+  const response = await fetch(docUrl);
+
+  if (!response.ok) {
+    throw new Error(`Fetch '${docUrl}' failed.`);
+  }
+
+  const text = await response.text();
+
+  await fs.writeFile(cacheFile, text);
+
+  return text;
+}
+
+function* parseCodeExample(nodes) {
+  for (let index = 0; index < nodes.length; index++) {
+    const node = nodes[index];
+    if (node.type === "inlineCode") {
+      yield node.value;
+    } else if (node.type === "html" && node.value === "<code>") {
+      const valueNode = nodes[++index];
+      const closingTagNode = nodes[++index];
+      assert.equal(closingTagNode.type, "html");
+      assert.equal(closingTagNode.value, "</code>");
+
+      assert.equal(valueNode.type, "text");
+      yield valueNode.value;
+    } else {
+      assert.equal(node.type, "text");
+      assert.equal(node.value.trim(), ",");
+    }
+  }
+}
+
+function* parsePluginTable(text) {
+  const tree = fromMarkdown(text, {
+    extensions: [gfmSyntax()],
+    mdastExtensions: [gfmFromMarkdown()],
+  });
+
+  assert.equal(tree.children.length, 1);
+  assert.equal(tree.children[0].type, "table");
+
+  const table = tree.children[0];
+
+  assert.ok(table.children.length > 2);
+
+  for (const row of table.children.slice(1)) {
+    const [nameCell, exampleCell] = row.children;
+
+    assert.equal(nameCell.children[0].type, "inlineCode");
+    const name = nameCell.children[0].value;
+    assert.ok(/^[a-z\d]+$/i.test(name), name);
+
+    const comment = text
+      .slice(nameCell.position.start.offset + 1, nameCell.position.end.offset)
+      .trim();
+
+    yield {
+      name,
+      comment,
+      examples: parseCodeExample(exampleCell.children).toArray(),
+    };
+  }
+}
+
+async function clean() {
+  const files = await fs.readdir(testDirectory);
+
+  await Promise.all(
+    files
+      .filter(
+        (file) => !(file === "format.test.js" || file === "__snapshots__"),
+      )
+      .map((file) => fs.rm(new URL(file, testDirectory))),
+  );
+}
+
+function* getExamples(text) {
+  const matches = text.matchAll(
+    /(?<=\n)\| Name\s* \| Code Example \s* \|\n.*?(?=\n\n)/gs,
+  );
+
+  for (const [text] of matches) {
+    for (const { name, comment, examples } of parsePluginTable(text)) {
+      for (const [index, code] of examples.entries()) {
+        const filename = `${dashify(name)}${index === 0 ? "" : `-${index + 1}`}.js`;
+        yield { filename, name, comment, code };
+      }
+    }
+  }
+}
+
+async function updateBabelPluginTests() {
+  const text = await getDoc();
+
+  await Promise.all(
+    getExamples(text).map(({ filename, comment, code }) =>
+      fs.writeFile(
+        new URL(filename, testDirectory),
+        outdent`
+          /*
+          ${comment}
+          */
+
+          ${code}
+        ` + "\n",
+      ),
+    ),
+  );
+}
+
+await clean();
+await updateBabelPluginTests();