update pull request

crates/signed_core/src/model.rs

@@ -284,6 +284,21 @@ impl Announcement {
         crate::repo_addr(self.owner, self.id.clone())
     }
 
+    /// Whether this announcement is a fork of the repository at `base`:
+    /// its `u` tag points at `base` (also covers permanent forks whose EUC
+    /// diverged), or it shares `base`'s earliest unique commit (EUC) and is
+    /// not the base repository itself. Read-only discovery input: nothing
+    /// here is published back to nostr.
+    pub fn is_fork_of(&self, base: &RepoAddr, base_euc: Option<&str>) -> bool {
+        if self.addr() == *base {
+            return false;
+        }
+        if self.upstream.as_ref().and_then(|u| u.addr.as_ref()) == Some(base) {
+            return true;
+        }
+        base_euc.is_some_and(|euc| self.euc.as_deref() == Some(euc))
+    }
+
     /// The description of the repository, or a default if none is provided.
     pub fn description(&self) -> SharedString {
         self.description
@@ -491,6 +506,78 @@ mod tests {
         );
     }
 
+    #[test]
+    fn is_fork_of_matches_the_u_tag_coordinate() {
+        // The base repository (announced by the `u`-tag's owner).
+        let base = crate::repo_addr(
+            PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey"),
+            "upstream",
+        );
+        let event = announcement_event(&[&["d", "my-fork"], &["u", &base.to_string()]]);
+        let fork = Announcement::from_event(&event).expect("parses");
+
+        // A `u` tag pointing at the base address marks a fork even when
+        // neither side announces an EUC.
+        assert!(fork.is_fork_of(&base, None));
+    }
+
+    #[test]
+    fn is_fork_of_matches_a_shared_euc() {
+        let euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        // The base repo has no `u` tag; it announces the family EUC.
+        let base_event = announcement_event(&[&["d", "upstream"], &["r", euc, "euc"]]);
+        let base = Announcement::from_event(&base_event).expect("parses");
+        let base_addr = base.addr();
+
+        // A fork (no `u` tag; a pure mirror or cross-hosted clone) shares
+        // the EUC, so clients of the family can find it.
+        let fork_event = announcement_event(&[&["d", "mirror"], &["r", euc, "euc"]]);
+        let fork = Announcement::from_event(&fork_event).expect("parses");
+        assert!(fork.is_fork_of(&base_addr, base.euc.as_deref()));
+
+        // An unrelated repository with a different EUC is not a fork.
+        let other_event = announcement_event(&[
+            &["d", "other"],
+            &["r", "bb231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+        ]);
+        let other = Announcement::from_event(&other_event).expect("parses");
+        assert!(!other.is_fork_of(&base_addr, base.euc.as_deref()));
+
+        // Without a base EUC there is nothing to compare against.
+        assert!(!fork.is_fork_of(&base_addr, None));
+    }
+
+    #[test]
+    fn is_fork_of_matches_permanent_forks_with_a_diverged_euc() {
+        // A permanent fork re-announces its EUC (first commit after the
+        // fork); only the `u` tag still relates it to the base.
+        let base = crate::repo_addr(
+            PublicKey::from_hex(MAINTAINER_HEX).expect("valid pubkey"),
+            "upstream",
+        );
+        let base_euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let event = announcement_event(&[
+            &["d", "my-fork"],
+            &["u", &base.to_string()],
+            &["r", "cc231c4c6a5777dc89b42207b499891a344add5c", "euc"],
+        ]);
+        let fork = Announcement::from_event(&event).expect("parses");
+
+        assert!(fork.is_fork_of(&base, Some(base_euc)));
+    }
+
+    #[test]
+    fn is_fork_of_excludes_the_base_itself() {
+        let euc = "aa231c4c6a5777dc89b42207b499891a344add5c";
+        let event = announcement_event(&[&["d", "upstream"], &["r", euc, "euc"]]);
+        let base = Announcement::from_event(&event).expect("parses");
+        let base_addr = base.addr();
+
+        // The base announcement matches its own EUC, but is not a fork of
+        // itself.
+        assert!(!base.is_fork_of(&base_addr, base.euc.as_deref()));
+    }
+
     #[test]
     fn effective_maintainers_include_owner_for_primary_repos() {
         let event = announcement_event(&[&["d", "my-repo"], &["maintainers", MAINTAINER_HEX]]);