update pull request

crates/signed_state/src/backend.rs

@@ -1546,6 +1546,70 @@ fn grasp_clone_url(relay: &RelayUrl, owner: &str, repo_id: &str) -> Option<Url>
     Url::parse(&format!("{base}/{owner}/{repo_id}.git")).ok()
 }
 
+/// The GRASP-06 contributor namespace URL of a pull request tip on the
+/// author's grasp server: `{base}/prs/<author-npub>/<repo-id>.git` (npub in
+/// the URL; the server stores it under the hex form). Anyone may push there;
+/// no announcement or maintainer rights are involved.
+pub(crate) fn grasp06_prs_url(base_url: &str, npub: &str, repo_id: &str) -> String {
+    format!("{base_url}/prs/{npub}/{repo_id}.git")
+}
+
+/// Assemble the `clone` URLs of a pull request: the author's GRASP-06
+/// `/prs/` URLs first (author-controlled, most likely to accept the tip
+/// push), then the base announcement's clone URLs, deduplicated while
+/// preserving that order.
+pub(crate) fn pr_clone_urls(prs_urls: Vec<Url>, base_clone_urls: Vec<Url>) -> Vec<Url> {
+    let mut seen = std::collections::HashSet::new();
+    let mut urls = Vec::new();
+    for url in prs_urls.into_iter().chain(base_clone_urls) {
+        if seen.insert(url.to_string()) {
+            urls.push(url);
+        }
+    }
+    urls
+}
+
+/// The `g` tag servers of one kind-10317 grasp list event, in tag order.
+/// Unparseable URLs are dropped (the UI only writes well-formed servers).
+fn grasp_list_servers(event: &Event) -> Vec<RelayUrl> {
+    event
+        .tags
+        .iter()
+        .filter(|tag| tag.kind() == "g")
+        .filter_map(|tag| tag.content())
+        .filter_map(|url| RelayUrl::parse(url).ok())
+        .collect()
+}
+
+/// The grasp servers of the newest kind-10317 grasp list among `events`
+/// (latest event wins, like every other latest-wins resolution in the app);
+/// empty when there is no list, so the caller falls back to the settings
+/// defaults.
+fn latest_grasp_list_servers(events: Vec<Event>) -> Vec<RelayUrl> {
+    events
+        .into_iter()
+        .max_by_key(|event| event.created_at)
+        .map(|event| grasp_list_servers(&event))
+        .unwrap_or_default()
+}
+
+/// Resolve the user's published grasp servers: the `g` tags (in order) of
+/// their latest kind-10317 grasp list in the local database. Returns an
+/// empty list when the user has no published list, so the caller can fall
+/// back to the settings defaults.
+pub(crate) async fn user_grasp_list_servers(
+    client: Client,
+    user: PublicKey,
+) -> Result<Vec<RelayUrl>, Error> {
+    let events: Vec<Event> = client
+        .database()
+        .query(filters::grasp_list(user))
+        .await?
+        .into_iter()
+        .collect();
+    Ok(latest_grasp_list_servers(events))
+}
+
 /// Push the repository at `path` to every grasp server: a server that
 /// rejects the push is logged, but the push only fails when no server
 /// accepted it. `push` performs the single-server push (e.g.
@@ -1628,4 +1692,90 @@ mod tests {
             "https://gitnostr.com/npub1test/my-repo.git"
         );
     }
+
+    #[test]
+    fn grasp06_prs_url_matches_ngit_format() {
+        assert_eq!(
+            grasp06_prs_url("https://relay.ngit.dev", "npub1author", "my-repo"),
+            "https://relay.ngit.dev/prs/npub1author/my-repo.git"
+        );
+        // `ws://` grasp servers (local dev) keep their plain-HTTP base.
+        assert_eq!(
+            grasp06_prs_url("http://localhost:8080", "npub1author", "my-repo"),
+            "http://localhost:8080/prs/npub1author/my-repo.git"
+        );
+    }
+
+    #[test]
+    fn pr_clone_urls_orders_author_first_and_deduplicates() {
+        let prs = vec![
+            Url::parse("https://a.example/prs/npub1me/repo.git").expect("url"),
+            Url::parse("https://a.example/prs/npub1me/repo.git").expect("url"),
+        ];
+        let base = vec![
+            Url::parse("https://a.example/npub1owner/repo.git").expect("url"),
+            Url::parse("https://b.example/npub1owner/repo.git").expect("url"),
+            Url::parse("https://b.example/npub1owner/repo.git").expect("url"),
+        ];
+
+        let urls = pr_clone_urls(prs, base);
+        assert_eq!(
+            urls.iter().map(ToString::to_string).collect::<Vec<_>>(),
+            vec![
+                "https://a.example/prs/npub1me/repo.git",
+                "https://a.example/npub1owner/repo.git",
+                "https://b.example/npub1owner/repo.git",
+            ]
+        );
+    }
+
+    fn grasp_list_event(servers: &[&str], created_at: u64) -> Event {
+        let keys = Keys::generate();
+        let tags: Vec<Tag> = servers
+            .iter()
+            .map(|url| Tag::parse(vec!["g", *url]).expect("valid tag"))
+            .collect();
+        EventBuilder::new(Kind::GitUserGraspList, "")
+            .tags(tags)
+            .custom_created_at(Timestamp::from(created_at))
+            .finalize(&keys)
+            .expect("signed event")
+    }
+
+    #[test]
+    fn grasp_list_servers_reads_g_tags_in_order() {
+        let event = grasp_list_event(
+            &["wss://first.example", "wss://second.example", "not a url"],
+            1000,
+        );
+
+        let servers = grasp_list_servers(&event);
+        assert_eq!(
+            servers.iter().map(ToString::to_string).collect::<Vec<_>>(),
+            vec!["wss://first.example", "wss://second.example"]
+        );
+    }
+
+    #[test]
+    fn latest_grasp_list_servers_takes_the_newest_list_and_falls_back_empty() {
+        let old = grasp_list_event(&["wss://old.example"], 1000);
+        let fresh = grasp_list_event(&["wss://fresh.example", "wss://also.example"], 2000);
+
+        // The newest list wins, its `g` order preserved.
+        let servers = latest_grasp_list_servers(vec![old.clone(), fresh.clone()]);
+        assert_eq!(
+            servers.iter().map(ToString::to_string).collect::<Vec<_>>(),
+            vec!["wss://fresh.example", "wss://also.example"]
+        );
+
+        // The order of the input events does not matter.
+        let servers = latest_grasp_list_servers(vec![fresh, old]);
+        assert_eq!(
+            servers.iter().map(ToString::to_string).collect::<Vec<_>>(),
+            vec!["wss://fresh.example", "wss://also.example"]
+        );
+
+        // No list at all: empty, so the caller falls back to the defaults.
+        assert!(latest_grasp_list_servers(Vec::new()).is_empty());
+    }
 }