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

series.js (5863B)

 // Collect a full patch series from one displayed message: find the sibling
 // patches in the same folder, order them, and fetch their plain-text bodies.
 
 import { parseSubject, sameSeries, bodyLooksLikeDiff, isReplySubject } from "./patch-detect.js";
 
 /** Extract the text/plain body from a messages.getFull() part tree. */
 export function plainBodyFromPart(part) {
   if (!part) {
     return "";
   }
   const contentType = (part.contentType || "").toLowerCase();
   if (contentType.startsWith("text/plain") && typeof part.body === "string") {
     return part.body;
   }
   for (const sub of part.parts || []) {
     const body = plainBodyFromPart(sub);
     if (body) {
       return body;
     }
   }
   // Fall back to any textual body at all (some senders use text/x-patch).
   if (typeof part.body === "string" && contentType.startsWith("text/")) {
     return part.body;
   }
   return "";
 }
 
 export async function getPlainBody(messageId) {
   const full = await messenger.messages.getFull(messageId);
   return plainBodyFromPart(full);
 }
 
 /** Query all messages in the anchor's folder within a date window, following pagination. */
 async function listFolderMessages(anchor, windowDays) {
   const from = new Date(anchor.date.getTime() - windowDays * 86400e3);
   const to = new Date(anchor.date.getTime() + windowDays * 86400e3);
   const base = { fromDate: from, toDate: to, subject: "PATCH" };
 
   let page;
   try {
     // TB 121+ addressing; falls back to the MailFolder object on TB 115.
     page = await messenger.messages.query({ ...base, folderId: anchor.folder.id });
   } catch (e) {
     page = await messenger.messages.query({ ...base, folder: anchor.folder });
   }
 
   const out = [...page.messages];
   while (page.id) {
     page = await messenger.messages.continueList(page.id);
     out.push(...page.messages);
   }
   return out;
 }
 
 /**
  * Collapse a list of same-series entries to one per series index.
  *
  * Each entry is { header, info, body, hasDiff } (only header.date,
  * header.headerMessageId, info.n and hasDiff are read here).
  *
  * For a real patch slot (n > 0) a body that carries a diff always beats one
  * that does not — a reply that shares the subject (some mailing lists strip
  * the "Re:" prefix) would otherwise win by date and surface as
  * "No diff found in this message". With no diff tiebreak, the more recent
  * message wins (handles resends of the same index).
  */
 export function dedupByIndex(entries) {
   const byIndex = new Map();
   for (const entry of entries) {
     const n = entry.info ? entry.info.n : null;
     const key = n === null ? `id:${entry.header.headerMessageId}` : n;
     const prev = byIndex.get(key);
     if (!prev) {
       byIndex.set(key, entry);
       continue;
     }
     if (n !== null && n > 0 && entry.hasDiff !== prev.hasDiff) {
       byIndex.set(key, entry.hasDiff ? entry : prev);
     } else {
       byIndex.set(key, entry.header.date > prev.header.date ? entry : prev);
     }
   }
   return byIndex;
 }
 
 /**
  * Build the ordered series for the given message header.
  * @returns {Promise<Array<{
  *   id: number, headerMessageId: string, subject: string, author: string,
  *   date: number, n: number|null, m: number|null, isCover: boolean,
  *   title: string, body: string, hasDiff: boolean
  * }>>} ordered patches (cover letter first when present)
  */
 export async function collectSeries(anchor) {
   const anchorInfo = parseSubject(anchor.subject);
   const members = new Map(); // headerMessageId -> {header, info}
 
   // Replies (Re:/Aw:/Fwd:) to a patch are not part of the series: skip the
   // anchor itself and every folder candidate that is a reply. The subject
   // tag still matches through the prefix, so we filter on the prefix here.
   if (!isReplySubject(anchor.subject)) {
     members.set(anchor.headerMessageId, { header: anchor, info: anchorInfo });
   }
 
   if (anchorInfo && anchorInfo.m !== null) {
     let candidates = [];
     try {
       candidates = await listFolderMessages(anchor, 30);
     } catch (e) {
       console.warn("patch-review: folder query failed, reviewing single message", e);
     }
     for (const header of candidates) {
       if (isReplySubject(header.subject)) {
         continue;
       }
       const info = parseSubject(header.subject);
       if (!sameSeries(anchorInfo, info)) {
         continue;
       }
       const existing = members.get(header.headerMessageId);
       if (!existing) {
         members.set(header.headerMessageId, { header, info });
       }
     }
   }
 
   // Fetch bodies up front so the per-index dedup can prefer the message
   // that actually carries a diff. A reply that shares the subject (some
   // mailing lists strip the "Re:" prefix, and isReplySubject only catches
   // the ones that keep it) would otherwise win the slot by date and show up
   // as "No diff found in this message".
   const entries = [];
   for (const { header, info } of members.values()) {
     const body = await getPlainBody(header.id);
     entries.push({ header, info, body, hasDiff: bodyLooksLikeDiff(body) });
   }
 
   // Keep one message per series index (a resend may duplicate an index).
   const byIndex = dedupByIndex(entries);
 
   const ordered = [...byIndex.values()].sort((a, b) => {
     const an = a.info && a.info.n !== null ? a.info.n : 0;
     const bn = b.info && b.info.n !== null ? b.info.n : 0;
     return an - bn || a.header.date - b.header.date;
   });
 
   const series = [];
   for (const { header, info, body, hasDiff } of ordered) {
     series.push({
       id: header.id,
       headerMessageId: header.headerMessageId,
       subject: header.subject,
       author: header.author,
       date: header.date.getTime ? header.date.getTime() : header.date,
       n: info ? info.n : null,
       m: info ? info.m : null,
       isCover: Boolean(info && info.n === 0),
       title: info ? info.title : header.subject,
       body,
       hasDiff,
     });
   }
   return series;
 }