feat(remote): `push` issues state event

if no previous state events can be found it replicates git server

otherwise it just updates pushed value

1 files changed, 199 insertions, 40 deletions

diff --git a/src/git_remote_helper.rs b/src/git_remote_helper.rs
index ba8ab61..68aa681 100644
--- a/src/git_remote_helper.rs
+++ b/src/git_remote_helper.rs
@@ -16,12 +16,17 @@ use anyhow::{bail, Context, Result};
 use auth_git2::GitAuthenticator;
 #[cfg(not(test))]
 use client::Connect;
-use client::{fetching_with_report, get_repo_ref_from_cache};
+use client::{
+    fetching_with_report, get_repo_ref_from_cache, get_state_from_cache, sign_event, STATE_KIND,
+};
 use git::RepoActions;
-use git2::{Remote, Repository};
+use git2::{Oid, Repository};
 use nostr::nips::nip01::Coordinate;
-use nostr_sdk::Url;
+use nostr_sdk::{EventBuilder, Tag, Url};
+use nostr_signer::NostrSigner;
 use repo_ref::RepoRef;
+use repo_state::RepoState;
+use sub_commands::send::send_events;
 
 #[cfg(not(test))]
 use crate::client::Client;
@@ -93,12 +98,14 @@ async fn main() -> Result<()> {
             }
             ["push", refspec] => {
                 push(
-                    &git_repo.git_repo,
+                    &git_repo,
                     &repo_ref,
                     nostr_remote_url,
                     &stdin,
                     refspec,
-                )?;
+                    &client,
+                )
+                .await?;
             }
             ["list"] => {
                 list(&git_repo.git_repo, &repo_ref, false)?;
@@ -171,12 +178,14 @@ fn fetch(git_repo: &Repository, repo_ref: &RepoRef, stdin: &Stdin, refstr: &str)
     Ok(())
 }
 
-fn push(
-    git_repo: &Repository,
+async fn push(
+    git_repo: &Repo,
     repo_ref: &RepoRef,
     nostr_remote_url: &str,
     stdin: &Stdin,
     initial_refspec: &str,
+    #[cfg(test)] client: &crate::client::MockConnect,
+    #[cfg(not(test))] client: &Client,
 ) -> Result<()> {
     // if no state events - create from first git server listed
     let refspecs = get_refspecs_from_push_batch(stdin, initial_refspec)?;
@@ -184,9 +193,10 @@ fn push(
         .git_server
         .first()
         .context("no git server listed in nostr repository announcement")?;
-    let mut git_server_remote = git_repo.remote_anonymous(git_server_url)?;
+    let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
+
     let auth = GitAuthenticator::default();
-    let git_config = git_repo.config()?;
+    let git_config = git_repo.git_repo.config()?;
     let mut push_options = git2::PushOptions::new();
     let mut remote_callbacks = git2::RemoteCallbacks::new();
     remote_callbacks.credentials(auth.credentials(&git_config));
@@ -198,8 +208,9 @@ fn push(
                 .iter()
                 .find(|r| r.contains(format!(":{name}").as_str()))
             {
-                if let Err(e) = update_remote_refs_pushed(git_repo, refspec, nostr_remote_url)
-                    .context("could not update remote_ref locally")
+                if let Err(e) =
+                    update_remote_refs_pushed(&git_repo.git_repo, refspec, nostr_remote_url)
+                        .context("could not update remote_ref locally")
                 {
                     return Err(git2::Error::from_str(e.to_string().as_str()));
                 }
@@ -211,49 +222,125 @@ fn push(
     push_options.remote_callbacks(remote_callbacks);
     git_server_remote.push(&refspecs, Some(&mut push_options))?;
     git_server_remote.disconnect()?;
+
+    // TODO check whether push was succesful before proceeding - geting outcome from
+    // callback isn't straightforward
+
+    let new_state = generate_updated_state(git_repo, repo_ref, &refspecs).await?;
+
+    // TODO enable interactive login
+    let (signer, user_ref) = login::launch(
+        git_repo,
+        &None,
+        &None,
+        &None,
+        &None,
+        Some(client),
+        false,
+        true,
+    )
+    .await?;
+    let new_repo_state = RepoState::build(repo_ref.identifier.clone(), new_state, &signer).await?;
+
+    send_events(
+        client,
+        git_repo.get_path()?,
+        vec![new_repo_state.event],
+        user_ref.relays.write(),
+        repo_ref.relays.clone(),
+        false,
+        true,
+    )
+    .await?;
+
     println!();
     Ok(())
 }
 
+async fn generate_updated_state(
+    git_repo: &Repo,
+    repo_ref: &RepoRef,
+    refspecs: &Vec<String>,
+) -> Result<Vec<(String, String)>> {
+    let new_state = {
+        if let Ok(mut repo_state) = get_state_from_cache(git_repo.get_path()?, repo_ref).await {
+            for refspec in refspecs {
+                let (from, to) = refspec_to_from_to(refspec)?;
+                if to.is_empty() {
+                    // delete
+                    repo_state.state.retain(|(name, _)| !name.eq(to));
+                } else if repo_state.state.iter().any(|(name, _)| name.eq(from)) {
+                    // update
+                    repo_state.state = repo_state
+                        .state
+                        .iter()
+                        .map(|(name, value)| {
+                            (
+                                name.clone(),
+                                if name.eq(to) {
+                                    reference_to_ref_value(&git_repo.git_repo, to).unwrap()
+                                } else {
+                                    value.to_string()
+                                },
+                            )
+                        })
+                        .collect();
+                } else {
+                    // add
+                    repo_state.state.push((
+                        to.to_string(),
+                        reference_to_ref_value(&git_repo.git_repo, to).unwrap(),
+                    ));
+                }
+            }
+            repo_state.state
+        } else {
+            let mut state = vec![];
+            let git_server_url = repo_ref
+                .git_server
+                .first()
+                .context("no git server listed in nostr repository announcement")?;
+            let mut git_server_remote = git_repo.git_repo.remote_anonymous(git_server_url)?;
+            git_server_remote.connect(git2::Direction::Fetch)?;
+            for head in git_server_remote.list()? {
+                state.push((
+                    head.name().to_string(),
+                    if let Some(symbolic_ref) = head.symref_target() {
+                        format!("ref: {}", symbolic_ref)
+                    } else {
+                        head.oid().to_string()
+                    },
+                ));
+            }
+            git_server_remote.disconnect()?;
+            state
+        }
+    };
+    Ok(new_state)
+}
+
 fn update_remote_refs_pushed(
     git_repo: &Repository,
     refspec: &str,
     nostr_remote_url: &str,
 ) -> Result<()> {
-    if !refspec.contains(':') {
-        bail!(
-            "refspec should contain a colon (:) but consists of: {}",
-            refspec
-        );
-    }
-    let parts = refspec.split(':').collect::<Vec<&str>>();
-    let from = parts.first().unwrap();
-    let to = parts.get(1).unwrap();
+    let (from, _) = refspec_to_from_to(refspec)?;
 
-    let nostr_remote = get_remote_by_url(git_repo, nostr_remote_url)?;
+    let target_ref_name = refspec_remote_ref_name(git_repo, refspec, nostr_remote_url)?;
 
-    let target_ref_name = format!(
-        "refs/remotes/{}/{}",
-        nostr_remote.name().context("remote should have a name")?,
-        to.replace("refs/heads/", ""), // TODO only replace if it begins with this
-    );
     if from.is_empty() {
         if let Ok(mut remote_ref) = git_repo.find_reference(&target_ref_name) {
             remote_ref.delete()?;
         }
     } else {
-        let local_ref = git_repo
-            .find_reference(from)
-            .context(format!("from ref in refspec should exist: {from}"))?;
-        let commit = local_ref
-            .peel_to_commit()
-            .context(format!("from ref in refspec should peel to commit: {from}"))?;
+        let commit = reference_to_commit(git_repo, from)
+            .context(format!("cannot get commit of reference {from}"))?;
         if let Ok(mut remote_ref) = git_repo.find_reference(&target_ref_name) {
-            remote_ref.set_target(commit.id(), "updated by nostr remote helper")?;
+            remote_ref.set_target(commit, "updated by nostr remote helper")?;
         } else {
             git_repo.reference(
                 &target_ref_name,
-                commit.id(),
+                commit,
                 false,
                 "created by nostr remote helper",
             )?;
@@ -262,9 +349,61 @@ fn update_remote_refs_pushed(
     Ok(())
 }
 
-fn get_remote_by_url<'a>(git_repo: &'a Repository, url: &'a str) -> Result<Remote<'a>> {
+fn refspec_to_from_to(refspec: &str) -> Result<(&str, &str)> {
+    if !refspec.contains(':') {
+        bail!(
+            "refspec should contain a colon (:) but consists of: {}",
+            refspec
+        );
+    }
+    let parts = refspec.split(':').collect::<Vec<&str>>();
+    Ok((parts.first().unwrap(), parts.get(1).unwrap()))
+}
+
+fn refspec_remote_ref_name(
+    git_repo: &Repository,
+    refspec: &str,
+    nostr_remote_url: &str,
+) -> Result<String> {
+    let (_, to) = refspec_to_from_to(refspec)?;
+    let nostr_remote = git_repo
+        .find_remote(&get_remote_name_by_url(git_repo, nostr_remote_url)?)
+        .context("we should have just located this remote")?;
+    Ok(format!(
+        "refs/remotes/{}/{}",
+        nostr_remote.name().context("remote should have a name")?,
+        to.replace("refs/heads/", ""), // TODO only replace if it begins with this
+    ))
+}
+
+fn reference_to_commit(git_repo: &Repository, reference: &str) -> Result<Oid> {
+    Ok(git_repo
+        .find_reference(reference)
+        .context(format!("cannot find reference: {reference}"))?
+        .peel_to_commit()
+        .context(format!("cannot get commit from reference: {reference}"))?
+        .id())
+}
+
+// this maybe a commit id or a ref: pointer
+fn reference_to_ref_value(git_repo: &Repository, reference: &str) -> Result<String> {
+    let reference_obj = git_repo
+        .find_reference(reference)
+        .context(format!("cannot find reference: {reference}"))?;
+    if let Some(symref) = reference_obj.symbolic_target() {
+        Ok(symref.to_string())
+    } else {
+        Ok(reference_obj
+            .peel_to_commit()
+            .context(format!("cannot get commit from reference: {reference}"))?
+            .id()
+            .to_string())
+    }
+}
+
+fn get_remote_name_by_url(git_repo: &Repository, url: &str) -> Result<String> {
     let remotes = git_repo.remotes()?;
-    let remote_name = remotes
+    Ok(remotes
         .iter()
         .find(|r| {
             if let Some(name) = r {
@@ -278,10 +417,8 @@ fn get_remote_by_url<'a>(git_repo: &'a Repository, url: &'a str) -> Result<Remot
             }
         })
         .context("could not find remote with matching url")?
-        .context("remote with matching url must be named")?;
-    git_repo
-        .find_remote(remote_name)
-        .context("we should have just located this remote")
+        .context("remote with matching url must be named")?
+        .to_string())
 }
 
 fn get_refstrs_from_fetch_batch(stdin: &Stdin, initial_refstr: &str) -> Result<Vec<String>> {
@@ -319,3 +456,25 @@ fn get_refspecs_from_push_batch(stdin: &Stdin, initial_refspec: &str) -> Result<
     }
     Ok(refspecs)
 }
+
+impl RepoState {
+    pub async fn build(
+        identifier: String,
+        state: Vec<(String, String)>,
+        signer: &NostrSigner,
+    ) -> Result<RepoState> {
+        let mut tags = vec![Tag::identifier(identifier.clone())];
+        for (name, value) in &state {
+            tags.push(Tag::custom(
+                nostr_sdk::TagKind::Custom(name.into()),
+                vec![value.clone()],
+            ));
+        }
+        let event = sign_event(EventBuilder::new(STATE_KIND, "", tags), signer).await?;
+        Ok(RepoState {
+            identifier,
+            state,
+            event,
+        })
+    }
+}