feat: intergrate `fetch` into `init`

as part of a project to use fetch and the stored cache everywhere

2 files changed, 43 insertions, 109 deletions

diff --git a/src/repo_ref.rs b/src/repo_ref.rs
index 5d754f2..a1ef11a 100644
--- a/src/repo_ref.rs
+++ b/src/repo_ref.rs
@@ -6,17 +6,12 @@ use std::{
 };
 
 use anyhow::{bail, Context, Result};
-use nostr::{
-    nips::{nip01::Coordinate, nip19::Nip19},
-    FromBech32, PublicKey, Tag, TagStandard, ToBech32,
-};
+use nostr::{nips::nip01::Coordinate, FromBech32, PublicKey, Tag, TagStandard, ToBech32};
 use nostr_sdk::{Kind, NostrSigner, Timestamp};
 use serde::{Deserialize, Serialize};
 
 #[cfg(not(test))]
 use crate::client::Client;
-#[cfg(test)]
-use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptInputParms},
     client::{get_event_from_global_cache, get_events_from_cache, sign_event, Connect},
@@ -224,6 +219,15 @@ pub async fn get_repo_coordinates(
     #[cfg(test)] client: &crate::client::MockConnect,
     #[cfg(not(test))] client: &Client,
 ) -> Result<HashSet<Coordinate>> {
+    try_and_get_repo_coordinates(git_repo, client, true).await
+}
+
+pub async fn try_and_get_repo_coordinates(
+    git_repo: &Repo,
+    #[cfg(test)] client: &crate::client::MockConnect,
+    #[cfg(not(test))] client: &Client,
+    prompt_user: bool,
+) -> Result<HashSet<Coordinate>> {
     let mut repo_coordinates = HashSet::new();
 
     if let Some(repo_override) = git_repo.get_git_config_item("nostr.repo", Some(false))? {
@@ -319,6 +323,9 @@ pub async fn get_repo_coordinates(
     }
 
     if repo_coordinates.is_empty() {
+        if !prompt_user {
+            bail!("couldn't find repo coordinates in git config nostr.repo or in maintainers.yaml");
+        }
         // TODO: present list of events filter by root_commit
         // TODO: fallback to search based on identifier
         let c = ask_for_naddr()?;
@@ -343,90 +350,6 @@ fn ask_for_naddr() -> Result<Coordinate> {
     })
 }
 
-pub async fn fetch(
-    git_repo: &Repo,
-    root_commit: String,
-    #[cfg(test)] client: &MockConnect,
-    #[cfg(not(test))] client: &Client,
-    // TODO: more rubust way of finding repo events
-    fallback_relays: Vec<String>,
-    prompt_for_nevent_if_cant_event: bool,
-) -> Result<RepoRef> {
-    let repo_config = get_repo_config_from_yaml(git_repo);
-
-    // TODO: check events only from maintainers. get relay list of maintainters.
-    // check those relays.
-
-    let mut repo_event_filter = nostr::Filter::default()
-        .kind(nostr::Kind::Custom(REPO_REF_KIND))
-        .reference(root_commit);
-
-    let mut relays = fallback_relays;
-    if let Ok(repo_config) = repo_config {
-        repo_event_filter =
-            repo_event_filter.authors(extract_pks(repo_config.maintainers.clone())?);
-        relays = repo_config.relays.clone();
-    }
-
-    let event = loop {
-        let events: Vec<nostr::Event> = client
-            .get_events(relays.clone(), vec![repo_event_filter.clone()])
-            .await?;
-
-        // TODO: if maintainers.yaml isn't present, as the user to select from the
-        // pubkeys they want to use. could use WoT as an indicator as well as the repo
-        // and user name.
-
-        // TODO: if maintainers.yaml isn't present, save the selected repo pubkey
-        // somewhere within .git folder for future use and seek to get that next time
-        if let Some(event) = events
-            .iter()
-            .filter(|e| e.kind.as_u16() == REPO_REF_KIND)
-            .max_by_key(|e| e.created_at)
-        {
-            break event.clone();
-        }
-        if !prompt_for_nevent_if_cant_event {
-            bail!("cannot find repo event");
-        }
-        println!("cannot find repo event");
-        loop {
-            let bech32 = Interactor::default()
-                .input(PromptInputParms::default().with_prompt("repository naddr or nevent"))?;
-            if let Ok(nip19) = Nip19::from_bech32(bech32) {
-                repo_event_filter =
-                    nostr::Filter::default().kind(nostr::Kind::Custom(REPO_REF_KIND));
-                match nip19 {
-                    Nip19::Coordinate(c) => {
-                        repo_event_filter = repo_event_filter
-                            .identifier(c.identifier)
-                            .author(c.public_key);
-                        for r in c.relays {
-                            relays.push(r);
-                        }
-                    }
-                    Nip19::Event(n) => {
-                        if let Some(author) = n.author {
-                            repo_event_filter = repo_event_filter.id(n.event_id).author(author);
-                        }
-                        for r in n.relays {
-                            relays.push(r);
-                        }
-                    }
-                    Nip19::EventId(id) => repo_event_filter = repo_event_filter.id(id),
-                    _ => (),
-                }
-            } else {
-                println!("not a valid nevent or naddr");
-                continue;
-            }
-            break;
-        }
-    };
-
-    RepoRef::try_from(event.clone()).context("cannot parse event as repo reference")
-}
-
 #[derive(Serialize, Deserialize, Default, Clone, Debug, PartialEq, Eq)]
 pub struct RepoConfigYaml {
     pub identifier: Option<String>,
diff --git a/src/sub_commands/init.rs b/src/sub_commands/init.rs
index e46bf74..2a97779 100644
--- a/src/sub_commands/init.rs
+++ b/src/sub_commands/init.rs
@@ -11,12 +11,12 @@ use crate::client::Client;
 use crate::client::MockConnect;
 use crate::{
     cli_interactor::{Interactor, InteractorPrompt, PromptInputParms},
-    client::Connect,
+    client::{fetching_with_report, get_repo_ref_from_cache, Connect},
     git::{Repo, RepoActions},
     login,
     repo_ref::{
-        self, extract_pks, get_repo_config_from_yaml, save_repo_config_to_yaml, RepoRef,
-        REPO_REF_KIND,
+        extract_pks, get_repo_config_from_yaml, save_repo_config_to_yaml,
+        try_and_get_repo_coordinates, RepoRef, REPO_REF_KIND,
     },
     Cli,
 };
@@ -66,6 +66,21 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     #[cfg(test)]
     let mut client = <MockConnect as std::default::Default>::default();
 
+    let repo_coordinates = if let Ok(repo_coordinates) =
+        try_and_get_repo_coordinates(&git_repo, &client, false).await
+    {
+        Some(repo_coordinates)
+    } else {
+        None
+    };
+
+    let repo_ref = if let Some(repo_coordinates) = repo_coordinates {
+        fetching_with_report(git_repo_path, &client, &repo_coordinates).await?;
+        Some(get_repo_ref_from_cache(git_repo_path, &repo_coordinates).await?)
+    } else {
+        None
+    };
+
     let (signer, user_ref) = login::launch(
         &git_repo,
         &cli_args.bunker_uri,
@@ -77,20 +92,6 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
     )
     .await?;
 
-    let repo_ref = if let Ok(rep_ref) = repo_ref::fetch(
-        &git_repo,
-        root_commit.to_string(),
-        &client,
-        user_ref.relays.write(),
-        false,
-    )
-    .await
-    {
-        Some(rep_ref)
-    } else {
-        None
-    };
-
     let repo_config_result = get_repo_config_from_yaml(&git_repo);
     // TODO: check for other claims
 
@@ -115,7 +116,8 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                 .with_default(if let Some(repo_ref) = &repo_ref {
                     repo_ref.identifier.clone()
                 } else {
-                    name.clone()
+                    let fallback = name
+                        .clone()
                         .replace(' ', "-")
                         .chars()
                         .map(|c| {
@@ -125,7 +127,16 @@ pub async fn launch(cli_args: &Cli, args: &SubCommandArgs) -> Result<()> {
                                 '-'
                             }
                         })
-                        .collect()
+                        .collect();
+                    if let Ok(config) = &repo_config_result {
+                        if let Some(identifier) = &config.identifier {
+                            identifier.to_string()
+                        } else {
+                            fallback
+                        }
+                    } else {
+                        fallback
+                    }
                 }),
         )?,
     };