thunderbird-patch-review

Easy-to-use patch review interface for Thunderbird

Contribute: ~marcc/thunderbird-review-plugin@lists.sr.ht

git clone git://mccd.space/thunderbird-patch-review

diff-parse.js (5752B)

 // Parse the body of a git format-patch email into commit message, diffstat,
 // and a structured diff. Every parsed element remembers the index of its
 // source line in the email body ("bodyLine") so replies can re-quote the
 // original text verbatim.
 
 const HUNK_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@ ?(.*)$/;
 const DIFF_GIT_RE = /^diff --git (?:"?a\/(.*?)"?) (?:"?b\/(.*?)"?)$/;
 
 /**
  * @param {string} text email body
  * @returns {{
  *   commitMessage: string,
  *   diffstat: string,
  *   files: Array<{
  *     oldPath: string, newPath: string, displayPath: string,
  *     isBinary: boolean, isNew: boolean, isDeleted: boolean, isRename: boolean,
  *     bodyLine: number,
  *     hunks: Array<{
  *       header: string, section: string, bodyLine: number,
  *       oldStart: number, oldCount: number, newStart: number, newCount: number,
  *       lines: Array<{origin: "add"|"del"|"ctx", text: string, raw: string,
  *                     bodyLine: number, oldLine: number|null, newLine: number|null}>
  *     }>
  *   }>,
  *   bodyLines: string[]
  * }}
  */
 export function parsePatchEmail(text) {
   const bodyLines = (text || "").split(/\r?\n/);
   const result = { commitMessage: "", diffstat: "", files: [], bodyLines };
 
   let firstDiff = bodyLines.findIndex((l) => DIFF_GIT_RE.test(l) || HUNK_RE.test(l));
   if (firstDiff === -1) {
     result.commitMessage = text || "";
     return result;
   }
 
   // The commit message ends at the "---" scissors line when present,
   // otherwise at the first diff line. Between the scissors and the diff
   // sits the diffstat.
   let scissors = -1;
   for (let i = 0; i < firstDiff; i++) {
     if (/^---\s*$/.test(bodyLines[i])) {
       scissors = i;
     }
   }
   const messageEnd = scissors === -1 ? firstDiff : scissors;
   // git format-patch prepends an mbox-style header block to the body
   // ("From <sha> Mon Sep 17 ...", From:, Date:, Subject:, then a blank
   // line). The UI shows author and subject separately, so drop that
   // block to keep only the real commit message text. reply-format does
   // not use commitMessage, so stripping is safe.
   let messageStart = 0;
   if (messageEnd > 0 && /^From .*Mon Sep 17 00:00:00 2001$/.test(bodyLines[0])) {
     let blank = 1;
     while (blank < messageEnd && bodyLines[blank] !== "") blank++;
     messageStart = Math.min(blank + 1, messageEnd);
   }
   result.commitMessage = bodyLines.slice(messageStart, messageEnd).join("\n").trim();
   if (scissors !== -1) {
     result.diffstat = bodyLines.slice(scissors + 1, firstDiff).join("\n").trim();
   }
 
   let file = null;
   let hunk = null;
   let oldLine = 0;
   let newLine = 0;
 
   const startFile = (oldPath, newPath, bodyLine) => {
     file = {
       oldPath,
       newPath,
       displayPath: newPath !== "/dev/null" && newPath ? newPath : oldPath,
       isBinary: false,
       isNew: false,
       isDeleted: false,
       isRename: false,
       bodyLine,
       hunks: [],
     };
     hunk = null;
     result.files.push(file);
   };
 
   for (let i = firstDiff; i < bodyLines.length; i++) {
     const line = bodyLines[i];
 
     // git format-patch signature trailer terminates the diff.
     if (/^-- ?$/.test(line) && hunk) {
       break;
     }
 
     const dg = DIFF_GIT_RE.exec(line);
     if (dg) {
       startFile(dg[1], dg[2], i);
       continue;
     }
 
     const h = HUNK_RE.exec(line);
     if (h) {
       if (!file) {
         startFile("", "", i);
       }
       hunk = {
         header: line,
         section: h[5] || "",
         bodyLine: i,
         oldStart: parseInt(h[1], 10),
         oldCount: h[2] === undefined ? 1 : parseInt(h[2], 10),
         newStart: parseInt(h[3], 10),
         newCount: h[4] === undefined ? 1 : parseInt(h[4], 10),
         consumedOld: 0,
         consumedNew: 0,
         lines: [],
       };
       oldLine = hunk.oldStart;
       newLine = hunk.newStart;
       file.hunks.push(hunk);
       continue;
     }
 
     if (file && !hunk) {
       // Extended header lines between "diff --git" and the first hunk.
       if (/^new file mode /.test(line)) file.isNew = true;
       else if (/^deleted file mode /.test(line)) file.isDeleted = true;
       else if (/^rename (from|to) /.test(line)) file.isRename = true;
       else if (/^Binary files /.test(line) || /^GIT binary patch/.test(line)) file.isBinary = true;
       else if (/^--- /.test(line)) file.oldPath = line.slice(4).replace(/^"?a\//, "").replace(/"$/, "");
       else if (/^\+\+\+ /.test(line)) {
         file.newPath = line.slice(4).replace(/^"?b\//, "").replace(/"$/, "");
         if (file.newPath !== "/dev/null") file.displayPath = file.newPath;
       }
       continue;
     }
 
     if (hunk) {
       const c = line[0];
       if (c === "+") {
         hunk.lines.push({ origin: "add", text: line.slice(1), raw: line, bodyLine: i, oldLine: null, newLine: newLine++ });
         hunk.consumedNew++;
       } else if (c === "-") {
         hunk.lines.push({ origin: "del", text: line.slice(1), raw: line, bodyLine: i, oldLine: oldLine++, newLine: null });
         hunk.consumedOld++;
       } else if (c === " " || line === "") {
         hunk.lines.push({ origin: "ctx", text: line.slice(1), raw: line, bodyLine: i, oldLine: oldLine++, newLine: newLine++ });
         hunk.consumedOld++;
         hunk.consumedNew++;
       } else if (c === "\\") {
         // "\ No newline at end of file" — attach as context-like metadata line.
         hunk.lines.push({ origin: "ctx", text: line, raw: line, bodyLine: i, oldLine: null, newLine: null });
       } else {
         // Anything else ends the current hunk (trailing chatter, next header).
         hunk = null;
       }
 
       if (hunk && hunk.consumedOld >= hunk.oldCount && hunk.consumedNew >= hunk.newCount) {
         hunk = null; // hunk complete
       }
     }
   }
 
   return result;
 }