Report formatting fixes on pull requests

Summary:
Add a GitHub Actions formatting check that runs the repository-wide formatter check and posts line-level suggested fixes through the GitHub API for files that need reformatting.

Changelog: [Internal]

Differential Revision: D119487616

Author: cortinico

.github/workflow-scripts/__tests__/reportFormattingErrors-test.js

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const {
+  commentableRightLines,
+  parsePatch,
+} = require('../reportFormattingErrors');
+
+describe('reportFormattingErrors', () => {
+  test('converts formatter hunks into minimal suggestions', () => {
+    const patch = `diff --git a/example.js b/example.js
+--- a/example.js
++++ b/example.js
+@@ -10,3 +10,3 @@
+ unchanged
+-const value={answer:42};
++const value = {answer: 42};
+ unchanged
+`;
+
+    expect(parsePatch(patch)).toEqual([
+      {
+        path: 'example.js',
+        startLine: 11,
+        endLine: 11,
+        replacement: 'const value = {answer: 42};',
+      },
+    ]);
+  });
+
+  test('tracks lines that can receive right-side review comments', () => {
+    const lines = commentableRightLines(`@@ -4,2 +4,3 @@
+ context
+-old
++new
++added
+`);
+
+    expect([...lines]).toEqual([4, 5, 6]);
+  });
+});

.github/workflow-scripts/reportFormattingErrors.js

@@ -0,0 +1,291 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @noflow
+ * @format
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MARKER = '<!-- react-native-format-report -->';
+const MAX_ARTIFACT_BYTES = 1024 * 1024;
+const MAX_COMMENTS = 20;
+const MAX_REPLACEMENT_LINES = 100;
+
+function readBoundedFile(file) {
+  const stat = fs.statSync(file);
+  if (stat.size > MAX_ARTIFACT_BYTES) {
+    throw new Error(`${path.basename(file)} exceeds the reporting size limit.`);
+  }
+  return fs.readFileSync(file, 'utf8');
+}
+
+function parsePatch(patch) {
+  const changes = [];
+  let file = null;
+  let hunk = null;
+
+  function finishHunk() {
+    if (file == null || hunk == null) {
+      return;
+    }
+    let prefix = 0;
+    while (
+      prefix < hunk.oldLines.length &&
+      prefix < hunk.newLines.length &&
+      hunk.oldLines[prefix] === hunk.newLines[prefix]
+    ) {
+      prefix++;
+    }
+    let suffix = 0;
+    while (
+      suffix < hunk.oldLines.length - prefix &&
+      suffix < hunk.newLines.length - prefix &&
+      hunk.oldLines[hunk.oldLines.length - suffix - 1] ===
+        hunk.newLines[hunk.newLines.length - suffix - 1]
+    ) {
+      suffix++;
+    }
+    const oldLines = hunk.oldLines.slice(prefix, hunk.oldLines.length - suffix);
+    const newLines = hunk.newLines.slice(prefix, hunk.newLines.length - suffix);
+    if (
+      oldLines.length > 0 &&
+      oldLines.length <= MAX_REPLACEMENT_LINES &&
+      newLines.length <= MAX_REPLACEMENT_LINES &&
+      !newLines.some(line => line.includes('```'))
+    ) {
+      const startLine = hunk.oldStart + prefix;
+      changes.push({
+        path: file,
+        startLine,
+        endLine: startLine + oldLines.length - 1,
+        replacement: newLines.join('\n'),
+      });
+    }
+    hunk = null;
+  }
+
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('diff --git ')) {
+      finishHunk();
+      file = null;
+    } else if (line.startsWith('+++ b/')) {
+      const candidate = line.slice(6);
+      file =
+        candidate.includes('\0') ||
+        candidate.split('/').includes('..') ||
+        path.posix.isAbsolute(candidate)
+          ? null
+          : candidate;
+    } else if (line.startsWith('@@ ')) {
+      finishHunk();
+      const match = /^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/.exec(line);
+      hunk =
+        match == null
+          ? null
+          : {oldStart: Number(match[1]), oldLines: [], newLines: []};
+    } else if (hunk != null && !line.startsWith('\\ No newline')) {
+      if (!line.startsWith('+')) {
+        hunk.oldLines.push(line.slice(1));
+      }
+      if (!line.startsWith('-')) {
+        hunk.newLines.push(line.slice(1));
+      }
+    }
+  }
+  finishHunk();
+  return changes;
+}
+
+function commentableRightLines(patch) {
+  const lines = new Set();
+  let newLine = 0;
+  for (const line of (patch ?? '').split('\n')) {
+    const match = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(line);
+    if (match != null) {
+      newLine = Number(match[1]);
+    } else if (line.startsWith('+') || line.startsWith(' ')) {
+      lines.add(newLine++);
+    } else if (
+      !line.startsWith('-') &&
+      !line.startsWith('\\ No newline') &&
+      newLine !== 0
+    ) {
+      newLine++;
+    }
+  }
+  return lines;
+}
+
+async function deletePreviousComments(github, owner, repo, pullNumber) {
+  const issueComments = await github.paginate(github.rest.issues.listComments, {
+    owner,
+    repo,
+    issue_number: pullNumber,
+    per_page: 100,
+  });
+  for (const comment of issueComments) {
+    if (
+      comment.user?.login === 'github-actions[bot]' &&
+      comment.body?.includes(MARKER)
+    ) {
+      await github.rest.issues.deleteComment({
+        owner,
+        repo,
+        comment_id: comment.id,
+      });
+    }
+  }
+
+  const reviewComments = await github.paginate(
+    github.rest.pulls.listReviewComments,
+    {owner, repo, pull_number: pullNumber, per_page: 100},
+  );
+  for (const comment of reviewComments) {
+    if (
+      comment.user?.login === 'github-actions[bot]' &&
+      comment.body?.includes(MARKER)
+    ) {
+      await github.rest.pulls.deleteReviewComment({
+        owner,
+        repo,
+        comment_id: comment.id,
+      });
+    }
+  }
+}
+
+module.exports = async function reportFormattingErrors({
+  github,
+  context,
+  core,
+}) {
+  const run = context.payload.workflow_run;
+  const pullRequests = run.pull_requests ?? [];
+  if (pullRequests.length !== 1) {
+    core.warning('Expected exactly one pull request for the formatting run.');
+    return;
+  }
+
+  const metadata = JSON.parse(readBoundedFile('.format-results/metadata.json'));
+  const pullNumber = Number(metadata.PR_NUMBER);
+  const headSha = metadata.HEAD_SHA;
+  if (
+    metadata.EVENT_NAME !== 'pull_request' ||
+    !Number.isSafeInteger(pullNumber) ||
+    pullNumber !== pullRequests[0].number ||
+    !/^[0-9a-f]{40}$/.test(headSha)
+  ) {
+    throw new Error('Formatting artifact metadata does not match this run.');
+  }
+
+  const {owner, repo} = context.repo;
+  const {data: pullRequest} = await github.rest.pulls.get({
+    owner,
+    repo,
+    pull_number: pullNumber,
+  });
+  if (pullRequest.head.sha !== headSha) {
+    core.info(
+      'Ignoring a stale formatting result for an older pull request revision.',
+    );
+    return;
+  }
+
+  await deletePreviousComments(github, owner, repo, pullNumber);
+  if (run.conclusion === 'success') {
+    return;
+  }
+
+  const patchFile = '.format-results/format.patch';
+  const patch = fs.existsSync(patchFile) ? readBoundedFile(patchFile) : '';
+  const outputFile = '.format-results/output.txt';
+  const output = fs.existsSync(outputFile) ? readBoundedFile(outputFile) : '';
+  const files = await github.paginate(github.rest.pulls.listFiles, {
+    owner,
+    repo,
+    pull_number: pullNumber,
+    per_page: 100,
+  });
+  const pullPatches = new Map(files.map(file => [file.filename, file.patch]));
+  const suggestions = parsePatch(patch)
+    .filter(change => {
+      const commentable = commentableRightLines(pullPatches.get(change.path));
+      return (
+        commentable.has(change.startLine) && commentable.has(change.endLine)
+      );
+    })
+    .slice(0, MAX_COMMENTS);
+
+  let postedSuggestions = 0;
+  for (const suggestion of suggestions) {
+    try {
+      const location =
+        suggestion.startLine === suggestion.endLine
+          ? {}
+          : {
+              start_line: suggestion.startLine,
+              start_side: 'RIGHT',
+            };
+      await github.rest.pulls.createReviewComment({
+        owner,
+        repo,
+        pull_number: pullNumber,
+        commit_id: headSha,
+        path: suggestion.path,
+        ...location,
+        line: suggestion.endLine,
+        side: 'RIGHT',
+        body: `${MARKER}\n\`yarn format\` suggests:\n\n\`\`\`suggestion\n${suggestion.replacement}\n\`\`\``,
+      });
+      postedSuggestions++;
+    } catch (error) {
+      core.warning(
+        `Could not attach a suggestion to ${suggestion.path}: ${error}`,
+      );
+    }
+  }
+
+  const changedFiles = [
+    ...new Set(parsePatch(patch).map(change => change.path)),
+  ];
+  const details =
+    changedFiles.length > 0
+      ? changedFiles.map(file => `- \`${file}\``).join('\n')
+      : 'The formatter stopped before producing a patch. See the workflow log.';
+  const outputExcerpt = output
+    .slice(-4000)
+    .replaceAll('```', '``\\`')
+    .replaceAll('<', '&lt;');
+  const body = `${MARKER}
+## Formatting required
+
+Run \`yarn format\` from the repository root and commit the result.
+
+${details}
+
+${postedSuggestions} inline suggestion${postedSuggestions === 1 ? '' : 's'} posted. Suggestions can only be attached to lines visible in the pull request diff.
+
+<details><summary>Formatter output</summary>
+
+\`\`\`text
+${outputExcerpt}
+\`\`\`
+</details>`;
+
+  await github.rest.issues.createComment({
+    owner,
+    repo,
+    issue_number: pullNumber,
+    body,
+  });
+};
+
+module.exports.parsePatch = parsePatch;
+module.exports.commentableRightLines = commentableRightLines;

.github/workflows/format-report.yml

@@ -0,0 +1,35 @@
+name: Format Report
+
+on:
+  workflow_run:
+    workflows: [Format]
+    types: [completed]
+
+permissions:
+  actions: read
+  contents: read
+  issues: write
+  pull-requests: write
+
+jobs:
+  report:
+    runs-on: ubuntu-latest
+    if: >-
+      github.repository == 'react/react-native' &&
+      github.event.workflow_run.event == 'pull_request'
+    steps:
+      - name: Check out trusted reporter
+        uses: actions/checkout@v6
+      - name: Download formatting report
+        uses: actions/download-artifact@v7
+        with:
+          name: format-results
+          path: .format-results
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ github.token }}
+      - name: Comment on formatting failures
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const reportFormattingErrors = require('./.github/workflow-scripts/reportFormattingErrors');
+            await reportFormattingErrors({github, context, core});