add pull request viewer

2026-08-22 20:38:22 +07:00
parent 385718d74d
commit 7fb7275233
9 changed files with 1737 additions and 187 deletions
@@ -9,6 +9,6 @@ pub mod status;
 pub use addr::{RepoAddr, repo_addr};
 pub use clone_url::{CloneTarget, parse_clone_url};
 pub use deletions::Deletions;
-pub use model::{activity_subject, Announcement};
+pub use model::{Announcement, activity_subject, pull_request_patch};
 pub use state::parse_state;
 pub use status::{RepoStatus, references_root, resolve_status};
@@ -50,6 +50,123 @@ pub fn activity_subject(event: &Event) -> SharedString {
        .unwrap_or(SharedString::from("Untitled"))
 }

+/// The patch set of a pull request: the root patch event (kind `1617`) the
+/// PR references via its `e` tag, plus every patch of the set chained to it
+/// with NIP-10 `e` reply tags, in series order (oldest first). When the PR
+/// has no `e` tag, falls back to the patch producing the PR's tip commit
+/// (its `commit`/`r` tag, per NIP-34) and walks the reply chain backward to
+/// the root.
+///
+/// Returns an empty list when no patch event can be linked to the PR.
+pub fn pull_request_patches<'a>(
+    pr: &Event,
+    patches: impl IntoIterator<Item = &'a Event>,
+) -> Vec<&'a Event> {
+    let patches: Vec<&'a Event> = patches.into_iter().collect();
+
+    // The PR references its root patch via an `e` tag; follow the NIP-10
+    // reply chain forward from there (each patch of the set replies to the
+    // previous one). Among several replies (a revision), the newest wins.
+    if let Some(root_id) = pr.tags.event_ids().next()
+        && let Some(root) = patches.iter().find(|patch| patch.id == root_id)
+    {
+        return forward_series(root, &patches);
+    }
+
+    // No `e` tag: the last patch of the set carries the PR's tip commit in
+    // its `commit`/`r` tag; walk the reply chain backward to the root.
+    let Some(tip) = current_commit_of(pr) else {
+        return Vec::new();
+    };
+    let Some(last) = patches
+        .iter()
+        .filter(|patch| patch_produces_commit(patch, &tip))
+        .max_by_key(|patch| patch.created_at)
+        .copied()
+    else {
+        return Vec::new();
+    };
+
+    let mut series = vec![last];
+    loop {
+        let Some(prev_id) = series.last().unwrap().tags.event_ids().next() else {
+            break;
+        };
+        let Some(prev) = patches
+            .iter()
+            .find(|patch| patch.id == prev_id && !series.contains(patch))
+            .copied()
+        else {
+            break;
+        };
+        series.push(prev);
+    }
+    series.reverse();
+    series
+}
+
+/// The patch content of a pull request: the contents of every patch event of
+/// its patch set (see [`pull_request_patches`]) joined in series order,
+/// falling back to the PR's own content for older PRs that carried the
+/// patch inline.
+pub fn pull_request_patch<'a>(pr: &Event, patches: impl IntoIterator<Item = &'a Event>) -> String {
+    let patches: Vec<&'a Event> = patches.into_iter().collect();
+    let series = pull_request_patches(pr, patches.iter().copied());
+    if series.is_empty() {
+        return pr.content.clone();
+    }
+    series
+        .iter()
+        .map(|patch| patch.content.as_str())
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// The chain of patches replying to `root` (NIP-10 `e` tags), oldest first.
+fn forward_series<'a>(root: &'a Event, patches: &[&'a Event]) -> Vec<&'a Event> {
+    let mut series = vec![root];
+    loop {
+        let next = patches
+            .iter()
+            .filter(|patch| !series.contains(patch))
+            .filter(|patch| {
+                patch
+                    .tags
+                    .event_ids()
+                    .any(|id| id == series.last().unwrap().id)
+            })
+            .max_by_key(|patch| patch.created_at);
+        let Some(next) = next else {
+            break;
+        };
+        series.push(next);
+    }
+    series
+}
+
+/// The `c` tag of an event (tip of the proposed branch), as hex.
+fn current_commit_of(event: &Event) -> Option<String> {
+    event
+        .tags
+        .iter()
+        .find_map(|tag| match Nip34Tag::parse(tag.as_slice()) {
+            Ok(Nip34Tag::CurrentCommit(commit)) => Some(commit.to_string()),
+            _ => None,
+        })
+}
+
+/// Whether `patch` produces `commit` (its `commit` or `r` tag), so clients
+/// can find existing patches for a specific commit.
+fn patch_produces_commit(patch: &Event, commit: &str) -> bool {
+    patch
+        .tags
+        .iter()
+        .any(|tag| match Nip34Tag::parse(tag.as_slice()) {
+            Ok(Nip34Tag::Commit(c) | Nip34Tag::Reference(c)) => c.to_string() == commit,
+            _ => false,
+        })
+}
+
 impl Announcement {
    /// Parse a kind `30617` event. Returns `None` if the kind is wrong or the `d` tag is missing.
    pub fn from_event(event: &Event) -> Option<Self> {
@@ -230,4 +347,131 @@ mod tests {
        assert!(announcement.name.is_none());
        assert!(announcement.web.is_empty());
    }
+
+    /// Build a signed PR event with the given tags and content.
+    fn pr_event(content: &str, tags: Vec<Tag>) -> Event {
+        EventBuilder::new(Kind::GitPullRequest, content)
+            .tags(tags)
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    #[test]
+    fn pull_request_patch_prefers_linked_patch_event() {
+        let patch = EventBuilder::new(Kind::GitPatch, "patch-content")
+            .finalize(&keys())
+            .expect("signed event");
+        let pr = pr_event("description", vec![Tag::event(patch.id)]);
+
+        assert_eq!(pull_request_patch(&pr, [&patch]), "patch-content");
+    }
+
+    #[test]
+    fn pull_request_patch_falls_back_to_inline_content() {
+        // Older PRs carried the patch in the content; no linked patch event.
+        let pr = pr_event("patch-inline", vec![]);
+
+        assert_eq!(pull_request_patch(&pr, [] as [&Event; 0]), "patch-inline");
+    }
+
+    #[test]
+    fn pull_request_patch_ignores_unrelated_patch_events() {
+        let patch = EventBuilder::new(Kind::GitPatch, "patch-content")
+            .finalize(&keys())
+            .expect("signed event");
+        let pr = pr_event("description", vec![]);
+
+        assert_eq!(pull_request_patch(&pr, [&patch]), "description");
+    }
+
+    /// Build a signed patch event with a controlled `created_at`.
+    fn patch_event(content: &str, tags: Vec<Tag>, created_at: u64) -> Event {
+        EventBuilder::new(Kind::GitPatch, content)
+            .tags(tags)
+            .custom_created_at(Timestamp::from(created_at))
+            .finalize(&keys())
+            .expect("signed event")
+    }
+
+    #[test]
+    fn pull_request_patch_joins_the_whole_patch_set() {
+        // NIP-34: a PR references the root patch; later patches of the set
+        // reply to the previous one (NIP-10 `e` tags).
+        let root = patch_event("patch-one", vec![], 100);
+        let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+        let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+        assert_eq!(
+            pull_request_patch(&pr, [&root, &second]),
+            "patch-one\npatch-two"
+        );
+        assert_eq!(
+            pull_request_patches(&pr, [&root, &second]),
+            vec![&root, &second]
+        );
+    }
+
+    #[test]
+    fn pull_request_patches_walks_the_reply_chain_in_order() {
+        let root = patch_event("patch-one", vec![], 100);
+        let second = patch_event("patch-two", vec![Tag::event(root.id)], 200);
+        let third = patch_event("patch-three", vec![Tag::event(second.id)], 300);
+        let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+        let series = pull_request_patches(&pr, [&third, &root, &second]);
+        assert_eq!(
+            series
+                .iter()
+                .map(|p| p.content.as_str())
+                .collect::<Vec<_>>(),
+            vec!["patch-one", "patch-two", "patch-three"]
+        );
+    }
+
+    #[test]
+    fn pull_request_patches_ignores_unrelated_replies() {
+        let root = patch_event("patch-one", vec![], 100);
+        let other = patch_event("other-patch", vec![Tag::event(root.id)], 250);
+        // A patch replying to a different root is not part of the set.
+        let stranger = patch_event("stranger", vec![], 150);
+        let pr = pr_event("description", vec![Tag::event(root.id)]);
+
+        let series = pull_request_patches(&pr, [&root, &other, &stranger]);
+        assert_eq!(
+            series
+                .iter()
+                .map(|p| p.content.as_str())
+                .collect::<Vec<_>>(),
+            vec!["patch-one", "other-patch"]
+        );
+    }
+
+    #[test]
+    fn pull_request_patches_finds_the_set_via_the_tip_commit() {
+        // PRs without an `e` tag: the last patch of the set carries the tip
+        // commit in its `r` tag; walk the reply chain backward to the root.
+        let root = patch_event("patch-one", vec![], 100);
+        let tip = "1111111111111111111111111111111111111111";
+        let last = patch_event(
+            "patch-two",
+            vec![
+                Tag::event(root.id),
+                Tag::parse(["r", tip]).expect("valid tag"),
+            ],
+            200,
+        );
+        let pr = pr_event(
+            "description",
+            vec![Tag::parse(["c", tip]).expect("valid tag")],
+        );
+
+        let series = pull_request_patches(&pr, [&root, &last]);
+        assert_eq!(
+            series
+                .iter()
+                .map(|p| p.content.as_str())
+                .collect::<Vec<_>>(),
+            vec!["patch-one", "patch-two"]
+        );
+    }
 }