Merge branch 'add-prs-to-ngit-send'

1 files changed, 252 insertions, 18 deletions

diff --git a/src/lib/push.rs b/src/lib/push.rs
index 0d0ec93..8cb0212 100644
--- a/src/lib/push.rs
+++ b/src/lib/push.rs
@@ -1,25 +1,38 @@
 use std::{
+    collections::{HashMap, HashSet},
     sync::{Arc, Mutex},
     time::Instant,
 };
 
-use anyhow::{Result, anyhow};
+use anyhow::{Context, Result, anyhow};
 use auth_git2::GitAuthenticator;
 use console::Term;
+use nostr::{
+    event::{Event, EventBuilder, Kind, Tag, TagStandard, UnsignedEvent},
+    hashes::sha1::Hash as Sha1Hash,
+    key::PublicKey,
+    nips::nip10::Marker,
+    signer::NostrSigner,
+};
 
 use crate::{
     cli_interactor::count_lines_per_msg_vec,
+    client::{sign_draft_event, sign_event},
     git::{
-        Repo,
+        Repo, RepoActions,
         nostr_url::{CloneUrl, NostrUrlDecoded},
         oid_to_shorthand_string,
     },
+    git_events::generate_unsigned_pr_or_update_event,
+    login::user::UserRef,
+    repo_ref::{RepoRef, is_grasp_server_clone_url, normalize_grasp_server_url},
     utils::{
         Direction, get_short_git_server_name, get_write_protocols_to_try, join_with_and,
         set_protocol_preference,
     },
 };
 
+// returns a HashMap of refs responded to and any related cancellation reasons
 pub fn push_to_remote(
     git_repo: &Repo,
     git_server_url: &str,
@@ -27,35 +40,65 @@ pub fn push_to_remote(
     remote_refspecs: &[String],
     term: &Term,
     is_grasp_server: bool,
-) -> Result<()> {
+) -> Result<HashMap<String, Option<String>>> {
     let server_url = git_server_url.parse::<CloneUrl>()?;
     let protocols_to_attempt =
         get_write_protocols_to_try(git_repo, &server_url, decoded_nostr_url, is_grasp_server);
 
     let mut failed_protocols = vec![];
     let mut success = false;
+    let mut ref_updates = HashMap::new();
 
     for protocol in &protocols_to_attempt {
         term.write_line(format!("push: {} over {protocol}...", server_url.short_name(),).as_str())?;
 
         let formatted_url = server_url.format_as(protocol, &decoded_nostr_url.user)?;
 
-        if let Err(error) = push_to_remote_url(git_repo, &formatted_url, remote_refspecs, term) {
-            term.write_line(
-                format!("push: {formatted_url} failed over {protocol}: {error}").as_str(),
-            )?;
-            failed_protocols.push(protocol);
-        } else {
-            success = true;
-            if !failed_protocols.is_empty() {
-                term.write_line(format!("push: succeeded over {protocol}").as_str())?;
-                let _ = set_protocol_preference(git_repo, protocol, &server_url, &Direction::Push);
+        match push_to_remote_url(git_repo, &formatted_url, remote_refspecs, term) {
+            Err(error) => {
+                term.write_line(
+                    format!("push: {formatted_url} failed over {protocol}: {error}").as_str(),
+                )?;
+                failed_protocols.push(protocol);
+            }
+            Ok(ref_updates_on_protocol) => {
+                success = true;
+                if ref_updates_on_protocol
+                    .values()
+                    .all(|error| error.is_none())
+                {
+                    if !failed_protocols.is_empty() {
+                        term.write_line(format!("push: succeeded over {protocol}").as_str())?;
+                        let _ = set_protocol_preference(
+                            git_repo,
+                            protocol,
+                            &server_url,
+                            &Direction::Push,
+                        );
+                    }
+                    break;
+                } else {
+                    term.write_line(
+                        format!(
+                            "push: {formatted_url} with {protocol} complete but {}ref{} not accepted:", 
+                            if remote_refspecs.len() != failed_protocols.len() { "some " } else {""},
+                            if remote_refspecs.len() == 1 { "s"} else {""},
+                        ).as_str(),
+                    )?;
+                    for (git_ref, error) in &ref_updates_on_protocol {
+                        if let Some(error) = error {
+                            term.write_line(format!("push:    - {git_ref}: {error}").as_str())?;
+                        }
+                    }
+                    // TODO do we want to report on the refs that weren't responded to?
+                    ref_updates = ref_updates_on_protocol;
+                }
+                break;
             }
-            break;
         }
     }
     if success {
-        Ok(())
+        Ok(ref_updates)
     } else {
         let error = anyhow!(
             "{} failed over {}{}",
@@ -72,12 +115,13 @@ pub fn push_to_remote(
     }
 }
 
+// returns HashMaps of refspecs responded to and any failure message
 pub fn push_to_remote_url(
     git_repo: &Repo,
     git_server_url: &str,
     remote_refspecs: &[String],
     term: &Term,
-) -> Result<()> {
+) -> Result<HashMap<String, Option<String>>> {
     let git_config = git_repo.git_repo.config()?;
     let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
     let auth = GitAuthenticator::default();
@@ -91,6 +135,9 @@ pub fn push_to_remote_url(
         let push_reporter = Arc::clone(&push_reporter);
         move |name, error| {
             let mut reporter = push_reporter.lock().unwrap();
+            reporter
+                .ref_updates
+                .insert(name.to_string(), error.map(|s| s.to_string()));
             if let Some(error) = error {
                 let existing_lines = reporter.count_all_existing_lines();
                 reporter.update_reference_errors.push(format!(
@@ -115,7 +162,11 @@ pub fn push_to_remote_url(
                     .unwrap_or("")
                     .replace("refs/heads/", "")
                     .replace("refs/tags/", "tags/");
-                let msg = if update.dst().is_zero() {
+                let msg = if let Some(Some(_)) =
+                    reporter.ref_updates.get(update.dst_refname().unwrap_or(""))
+                {
+                    format!("push: - [failed]          {dst_refname}")
+                } else if update.dst().is_zero() {
                     format!("push: - [delete]          {dst_refname}")
                 } else if update.src().is_zero() {
                     if update.dst_refname().unwrap_or("").contains("refs/tags") {
@@ -174,7 +225,8 @@ pub fn push_to_remote_url(
     push_options.remote_callbacks(remote_callbacks);
     git_server_remote.push(remote_refspecs, Some(&mut push_options))?;
     let _ = git_server_remote.disconnect();
-    Ok(())
+    let reporter = push_reporter.lock().unwrap();
+    Ok(reporter.ref_updates.clone())
 }
 
 #[allow(clippy::cast_precision_loss)]
@@ -223,6 +275,7 @@ pub struct PushReporter<'a> {
     negotiation: Vec<String>,
     transfer_progress_msgs: Vec<String>,
     update_reference_errors: Vec<String>,
+    ref_updates: HashMap<String, Option<String>>,
     term: &'a console::Term,
     start_time: Option<Instant>,
     end_time: Option<Instant>,
@@ -234,6 +287,7 @@ impl<'a> PushReporter<'a> {
             negotiation: vec![],
             transfer_progress_msgs: vec![],
             update_reference_errors: vec![],
+            ref_updates: HashMap::new(),
             term,
             start_time: None,
             end_time: None,
@@ -308,3 +362,183 @@ impl<'a> PushReporter<'a> {
         }
     }
 }
+
+#[allow(clippy::too_many_arguments)]
+pub async fn push_refs_and_generate_pr_or_pr_update_event(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    tip: &Sha1Hash,
+    user_ref: &UserRef,
+    root_proposal: Option<&Event>,
+    title_description_overide: &Option<(String, String)>,
+    servers: &[String],
+    git_ref: Option<String>,
+    signer: &Arc<dyn NostrSigner>,
+    term: &Term,
+) -> Result<(Option<Vec<Event>>, Vec<(String, Result<()>)>)> {
+    let mut responses: Vec<(String, Result<()>)> = vec![];
+
+    let mut unsigned_pr_event: Option<UnsignedEvent> = None;
+    for clone_url in servers {
+        let mut draft_pr_event = if let Some(ref unsigned_pr_event) = unsigned_pr_event {
+            unsigned_pr_event.clone()
+        } else {
+            generate_unsigned_pr_or_update_event(
+                git_repo,
+                repo_ref,
+                &user_ref.public_key,
+                root_proposal,
+                title_description_overide,
+                tip,
+                &[clone_url],
+                &[],
+            )?
+        };
+
+        let git_ref_used = git_ref
+            .clone()
+            .unwrap_or("refs/nostr/<event-id>".to_string())
+            .replace("<event-id>", &draft_pr_event.id().to_string());
+
+        let refspec = format!("{tip}:{git_ref_used}");
+
+        let res = if is_grasp_server_clone_url(clone_url) {
+            push_to_remote_url(git_repo, clone_url, &[refspec], term)
+        } else {
+            // anticipated only when pushing to user's own repo or a personal-fork with
+            // non-grasp git servers. this is used to extract prefered protocols / ssh
+            // details from nostr url
+            let decoded_nostr_url = {
+                if let Ok(Some((_, decoded_nostr_url))) = git_repo
+                .get_first_nostr_remote_when_in_ngit_binary()
+                .await.context("failed to list git remotes")
+                .context("no `nostr://` remote detected. `ngit sync` must be run from a repo with a nostr remote") {
+                    decoded_nostr_url
+                } else {
+                    repo_ref.to_nostr_git_url(&Some(git_repo))
+                }
+            };
+            push_to_remote(
+                git_repo,
+                clone_url,
+                &decoded_nostr_url,
+                &[refspec],
+                term,
+                false,
+            )
+        };
+
+        match res {
+            Err(error) => {
+                let normalized_url = normalize_grasp_server_url(clone_url)?;
+                term.write_line(&format!(
+                    "push: error sending commit data to {normalized_url}: {error}"
+                ))?;
+                responses.push((clone_url.clone(), Err(anyhow!(error))));
+            }
+            Ok(ref_updates) => {
+                let normalized_url = normalize_grasp_server_url(clone_url)?;
+                if let Some((_, Some(error))) = ref_updates.iter().next() {
+                    term.write_line(&format!(
+                        "push: error sending commit data to {normalized_url}: {error}"
+                    ))?;
+                    responses.push((clone_url.clone(), Err(anyhow!(error.clone()))));
+                } else {
+                    responses.push((clone_url.clone(), Ok(())));
+                    term.write_line(&format!("push: commit data sent to {normalized_url}"))?;
+                    unsigned_pr_event = Some(draft_pr_event);
+                }
+            }
+        }
+    }
+    if let Some(unsigned_pr_event) = unsigned_pr_event {
+        let pr_event = sign_draft_event(
+            unsigned_pr_event,
+            signer,
+            if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+                "Pull Request Replacing Original Patch"
+            } else if root_proposal.is_some() {
+                "Pull Request Update"
+            } else {
+                "Pull Request"
+            }
+            .to_string(),
+        )
+        .await?;
+        if root_proposal.is_some_and(|proposal| proposal.kind.eq(&Kind::GitPatch)) {
+            Ok((
+                Some(vec![
+                    pr_event,
+                    create_close_status_for_original_patch(
+                        signer,
+                        repo_ref,
+                        root_proposal.unwrap(),
+                    )
+                    .await?,
+                ]),
+                responses,
+            ))
+        } else {
+            Ok((Some(vec![pr_event]), responses))
+        }
+    } else {
+        Ok((None, responses))
+    }
+}
+
+async fn create_close_status_for_original_patch(
+    signer: &Arc<dyn NostrSigner>,
+    repo_ref: &RepoRef,
+    proposal: &Event,
+) -> Result<Event> {
+    let mut public_keys = repo_ref
+        .maintainers
+        .iter()
+        .copied()
+        .collect::<HashSet<PublicKey>>();
+    public_keys.insert(proposal.pubkey);
+
+    sign_event(
+        EventBuilder::new(nostr::event::Kind::GitStatusClosed, String::new()).tags(
+            [
+                vec![
+                    Tag::custom(
+                        nostr::TagKind::Custom(std::borrow::Cow::Borrowed("alt")),
+                        vec![
+                            "Git patch closed as forthcoming update is too large. Replacing with Pull Request"
+                                .to_string(),
+                        ],
+                    ),
+                    Tag::from_standardized(nostr::TagStandard::Event {
+                        event_id: proposal.id,
+                        relay_url: repo_ref.relays.first().cloned(),
+                        marker: Some(Marker::Root),
+                        public_key: None,
+                        uppercase: false,
+                    }),
+                ],
+                public_keys.iter().map(|pk| Tag::public_key(*pk)).collect(),
+                repo_ref
+                    .coordinates()
+                    .iter()
+                    .map(|c| {
+                        Tag::from_standardized(TagStandard::Coordinate {
+                            coordinate: c.coordinate.clone(),
+                            relay_url: c.relays.first().cloned(),
+                            uppercase: false,
+                        })
+                    })
+                    .collect::<Vec<Tag>>(),
+                vec![
+                    Tag::from_standardized(nostr::TagStandard::Reference(
+                        repo_ref.root_commit.to_string(),
+                    )),
+                ],
+            ]
+            .concat(),
+        ),
+        signer,
+        "close status for original patch".to_string(),
+    )
+    .await
+}