From 40b439ae4d69b858274be51dd5af513c3b4f46f0 Mon Sep 17 00:00:00 2001 From: DanConwayDev Date: Fri, 13 Feb 2026 10:51:25 +0000 Subject: feat: add spinner for git fetch in non-verbose mode Shows a progress spinner when fetching from git remotes in non-verbose mode. Suppresses git fetch output and listing messages when not in verbose mode. Uses NGITTEST environment variable for test timeouts. --- src/bin/git_remote_nostr/list.rs | 6 +- src/bin/git_remote_nostr/main.rs | 13 ++-- src/bin/ngit/main.rs | 6 +- src/bin/ngit/sub_commands/apply.rs | 55 +++++++++++++-- src/bin/ngit/sub_commands/checkout.rs | 55 +++++++++++++-- src/bin/ngit/sub_commands/list.rs | 60 +++++++++++++--- src/lib/client.rs | 126 +++++++++++++++++++++++++++------- src/lib/list.rs | 110 ++++++++++++++++++++++++----- 8 files changed, 354 insertions(+), 77 deletions(-) diff --git a/src/bin/git_remote_nostr/list.rs b/src/bin/git_remote_nostr/list.rs index 7753ba1..4a7c1ec 100644 --- a/src/bin/git_remote_nostr/list.rs +++ b/src/bin/git_remote_nostr/list.rs @@ -4,7 +4,7 @@ use anyhow::{Context, Result}; use client::get_state_from_cache; use git::RepoActions; use ngit::{ - client, + client::{self, is_verbose}, fetch::fetch_from_git_server, git::{self}, git_events::{KIND_PULL_REQUEST, KIND_PULL_REQUEST_UPDATE, event_to_cover_letter, tag_value}, @@ -27,7 +27,9 @@ pub async fn run_list( let term = console::Term::stderr(); - term.write_line("git servers: listing refs...")?; + if is_verbose() { + term.write_line("git servers: listing refs...")?; + } let remote_states = list_from_remotes( &term, git_repo, diff --git a/src/bin/git_remote_nostr/main.rs b/src/bin/git_remote_nostr/main.rs index b26981d..3663d5b 100644 --- a/src/bin/git_remote_nostr/main.rs +++ b/src/bin/git_remote_nostr/main.rs @@ -12,7 +12,7 @@ use std::{ }; use anyhow::{Context, Result, bail}; -use client::{Connect, consolidate_fetch_reports, get_repo_ref_from_cache}; +use client::{Connect, consolidate_fetch_reports, get_repo_ref_from_cache, is_verbose}; use git::{RepoActions, nostr_url::NostrUrlDecoded}; use ngit::{ client::{self, Params}, @@ -156,7 +156,10 @@ async fn fetching_with_report_for_helper( trusted_maintainer_coordinate: &Nip19Coordinate, ) -> Result<()> { let term = console::Term::stderr(); - term.write_line("nostr: fetching...")?; + let verbose = is_verbose(); + if verbose { + term.write_line("nostr: fetching...")?; + } let (relay_reports, progress_reporter) = client .fetch_all( Some(git_repo_path), @@ -166,10 +169,12 @@ async fn fetching_with_report_for_helper( .await?; let report = consolidate_fetch_reports(relay_reports); if report.to_string().is_empty() { - term.write_line("nostr: no updates")?; + if verbose { + term.write_line("nostr: no updates")?; + } } else { term.write_line(&format!("nostr updates: {report}"))?; } - progress_reporter.clear()?; + let _ = progress_reporter.clear(); Ok(()) } diff --git a/src/bin/ngit/main.rs b/src/bin/ngit/main.rs index 65f6bca..77ef955 100644 --- a/src/bin/ngit/main.rs +++ b/src/bin/ngit/main.rs @@ -15,10 +15,6 @@ use ngit::{ mod sub_commands; -fn is_verbose() -> bool { - std::env::var("NGIT_VERBOSE").is_ok() || std::env::var("NGIT_TEST").is_ok() -} - #[tokio::main] async fn main() { let cli = Cli::parse(); @@ -29,7 +25,7 @@ async fn main() { std::env::set_var("NGIT_INTERACTIVE_MODE", "1"); } - if cli.verbose || std::env::var("NGIT_TEST").is_ok() { + if cli.verbose || std::env::var("NGITTEST").is_ok() { std::env::set_var("NGIT_VERBOSE", "1"); } diff --git a/src/bin/ngit/sub_commands/apply.rs b/src/bin/ngit/sub_commands/apply.rs index 4ed6caa..2d5d8d5 100644 --- a/src/bin/ngit/sub_commands/apply.rs +++ b/src/bin/ngit/sub_commands/apply.rs @@ -1,9 +1,11 @@ use std::{ io::Write, process::{Command, Stdio}, + time::Duration, }; use anyhow::{Context, Result, bail}; +use indicatif::{ProgressBar, ProgressStyle}; use ngit::{ client::get_all_proposal_patch_pr_pr_update_events_from_cache, git_events::get_pr_tip_event_or_most_recent_patch_with_ancestors, @@ -18,16 +20,55 @@ use crate::{ }; fn run_git_fetch(remote_name: &str) -> Result<()> { - println!("fetching from {remote_name}..."); - let exit_status = Command::new("git") + let verbose = ngit::client::is_verbose(); + if verbose { + println!("fetching from {remote_name}..."); + } + + let spinner = if verbose { + None + } else { + let pb = ProgressBar::new_spinner() + .with_style( + ProgressStyle::with_template("{spinner} {msg}") + .unwrap() + .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"), + ) + .with_message(format!("Fetching from {remote_name}...")); + pb.enable_steady_tick(Duration::from_millis(100)); + Some(pb) + }; + + let output = Command::new("git") .args(["fetch", remote_name]) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) - .status() + .stdout(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .stderr(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .output() .context("failed to run git fetch")?; - if !exit_status.success() { - bail!("git fetch {remote_name} exited with error: {exit_status}"); + if let Some(spinner) = spinner { + spinner.finish_and_clear(); + } + + if !output.status.success() { + if !verbose { + let stderr = String::from_utf8_lossy(&output.stderr); + if !stderr.is_empty() { + eprintln!("{stderr}"); + } + } + bail!( + "git fetch {remote_name} exited with error: {}", + output.status + ); } Ok(()) } diff --git a/src/bin/ngit/sub_commands/checkout.rs b/src/bin/ngit/sub_commands/checkout.rs index 6ded778..2fc9a09 100644 --- a/src/bin/ngit/sub_commands/checkout.rs +++ b/src/bin/ngit/sub_commands/checkout.rs @@ -1,9 +1,11 @@ use std::{ collections::HashSet, process::{Command, Stdio}, + time::Duration, }; use anyhow::{Context, Result, bail}; +use indicatif::{ProgressBar, ProgressStyle}; use ngit::{ client::{ Params, get_all_proposal_patch_pr_pr_update_events_from_cache, @@ -97,16 +99,55 @@ pub async fn launch(id: &str) -> Result<()> { } fn run_git_fetch(remote_name: &str) -> Result<()> { - println!("fetching from {remote_name}..."); - let exit_status = Command::new("git") + let verbose = ngit::client::is_verbose(); + if verbose { + println!("fetching from {remote_name}..."); + } + + let spinner = if verbose { + None + } else { + let pb = ProgressBar::new_spinner() + .with_style( + ProgressStyle::with_template("{spinner} {msg}") + .unwrap() + .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"), + ) + .with_message(format!("Fetching from {remote_name}...")); + pb.enable_steady_tick(Duration::from_millis(100)); + Some(pb) + }; + + let output = Command::new("git") .args(["fetch", remote_name]) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) - .status() + .stdout(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .stderr(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .output() .context("failed to run git fetch")?; - if !exit_status.success() { - bail!("git fetch {remote_name} exited with error: {exit_status}"); + if let Some(spinner) = spinner { + spinner.finish_and_clear(); + } + + if !output.status.success() { + if !verbose { + let stderr = String::from_utf8_lossy(&output.stderr); + if !stderr.is_empty() { + eprintln!("{stderr}"); + } + } + bail!( + "git fetch {remote_name} exited with error: {}", + output.status + ); } Ok(()) } diff --git a/src/bin/ngit/sub_commands/list.rs b/src/bin/ngit/sub_commands/list.rs index 68a10cc..ff43bd9 100644 --- a/src/bin/ngit/sub_commands/list.rs +++ b/src/bin/ngit/sub_commands/list.rs @@ -3,9 +3,11 @@ use std::{ io::Write, ops::Add, process::{Command, Stdio}, + time::Duration, }; use anyhow::{Context, Result, bail}; +use indicatif::{ProgressBar, ProgressStyle}; use ngit::{ client::{ Params, get_all_proposal_patch_pr_pr_update_events_from_cache, @@ -39,16 +41,55 @@ use crate::{ }; fn run_git_fetch(remote_name: &str) -> Result<()> { - println!("fetching from {remote_name}..."); - let exit_status = Command::new("git") + let verbose = ngit::client::is_verbose(); + if verbose { + println!("fetching from {remote_name}..."); + } + + let spinner = if verbose { + None + } else { + let pb = ProgressBar::new_spinner() + .with_style( + ProgressStyle::with_template("{spinner} {msg}") + .unwrap() + .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"), + ) + .with_message(format!("Fetching from {remote_name}...")); + pb.enable_steady_tick(Duration::from_millis(100)); + Some(pb) + }; + + let output = Command::new("git") .args(["fetch", remote_name]) - .stdout(Stdio::inherit()) - .stderr(Stdio::inherit()) - .status() + .stdout(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .stderr(if verbose { + Stdio::inherit() + } else { + Stdio::piped() + }) + .output() .context("failed to run git fetch")?; - if !exit_status.success() { - bail!("git fetch {remote_name} exited with error: {exit_status}"); + if let Some(spinner) = spinner { + spinner.finish_and_clear(); + } + + if !output.status.success() { + if !verbose { + let stderr = String::from_utf8_lossy(&output.stderr); + if !stderr.is_empty() { + eprintln!("{stderr}"); + } + } + bail!( + "git fetch {remote_name} exited with error: {}", + output.status + ); } Ok(()) } @@ -297,10 +338,7 @@ fn show_proposal_details( } println!(); - println!( - "To checkout: ngit checkout {}", - proposal.id - ); + println!("To checkout: ngit checkout {}", proposal.id); println!("To apply: ngit apply {}", proposal.id); Ok(()) diff --git a/src/lib/client.rs b/src/lib/client.rs index 89fcaf7..583f01c 100644 --- a/src/lib/client.rs +++ b/src/lib/client.rs @@ -16,10 +16,10 @@ use std::{ fs::create_dir_all, path::Path, sync::{ - Arc, RwLock, + Arc, Mutex, RwLock, atomic::{AtomicU64, Ordering}, }, - time::Duration, + time::{Duration, Instant}, }; use anyhow::{Context, Result, anyhow, bail}; @@ -65,6 +65,65 @@ use crate::{ repo_state::RepoState, }; +pub fn is_verbose() -> bool { + std::env::var("NGIT_VERBOSE").is_ok() +} + +const SPINNER_EXPAND_DELAY_SECS: u64 = 5; + +struct SpinnerState { + spinner: ProgressBar, + start_time: Instant, + expanded_multi: Option, +} + +impl SpinnerState { + fn new() -> Self { + let multi_progress = MultiProgress::new(); + let spinner = multi_progress.add( + ProgressBar::new_spinner() + .with_style( + ProgressStyle::with_template("{spinner} {msg}") + .unwrap() + .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"), + ) + .with_message("Checking relays and git servers..."), + ); + spinner.enable_steady_tick(Duration::from_millis(100)); + Self { + spinner, + start_time: Instant::now(), + expanded_multi: None, + } + } + + fn should_expand(&self) -> bool { + self.expanded_multi.is_none() + && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS + } + + fn expand(&mut self) -> &MultiProgress { + if self.expanded_multi.is_none() { + self.spinner.finish_and_clear(); + self.expanded_multi = Some(MultiProgress::new()); + } + self.expanded_multi.as_ref().unwrap() + } + + fn finish(&self, has_errors: bool) { + if has_errors { + if let Some(ref multi) = self.expanded_multi { + let _ = multi.clear(); + } + } else { + self.spinner.finish_and_clear(); + if let Some(ref multi) = self.expanded_multi { + let _ = multi.clear(); + } + } + } +} + #[allow(clippy::struct_field_names)] pub struct Client { client: nostr_sdk::Client, @@ -370,14 +429,15 @@ impl Connect for Client { ) .await?; + let verbose = is_verbose(); + let spinner_state = if !verbose { + Some(Arc::new(Mutex::new(SpinnerState::new()))) + } else { + None + }; let progress_reporter = MultiProgress::new(); - // Track successful relays for adaptive timeout (switch to SHORT when - // SUCCESS_THRESHOLD succeed) let success_count = Arc::new(AtomicU64::new(0)); - - // Track current timeout value for progress bar display (starts at LONG, - // switches to SHORT) let current_timeout = Arc::new(AtomicU64::new(long_timeout())); let mut processed_relays = HashSet::new(); @@ -388,7 +448,6 @@ impl Connect for Client { let relays = request .repo_relays .union(&request.user_relays_for_profiles) - // don't look for events on blaster .filter(|&r| !r.as_str().contains("nostr.mutinywallet.com")) .cloned() .collect::>() @@ -412,12 +471,12 @@ impl Connect for Client { let success_count_for_loop = success_count.clone(); let current_timeout_for_loop = current_timeout.clone(); let total_relays = relays.len() as u64; + let spinner_state_clone = spinner_state.clone(); let futures: Vec<_> = relays .iter() .map(|r| { if profile_relays_only.contains(r) { - // if relay isn't a repo relay, just filter for user profile FetchRequest { selected_relay: Some(r.to_owned()), repo_coordinates_without_relays: vec![], @@ -447,6 +506,8 @@ impl Connect for Client { let current_timeout_clone = current_timeout_for_loop.clone(); let progress_reporter_clone = progress_reporter.clone(); let total_relays_clone = total_relays; + let spinner_state_for_task = spinner_state_clone.clone(); + let verbose_for_task = verbose; async move { let relay_column_width = request.relay_column_width; @@ -455,7 +516,7 @@ impl Connect for Client { .clone() .context("fetch_all_from_relay called without a relay")?; - let pb = if std::env::var("NGITTEST").is_err() { + let pb = if verbose_for_task { let pb = progress_reporter_clone.add( ProgressBar::new(1) .with_prefix( @@ -469,6 +530,26 @@ impl Connect for Client { ); pb.enable_steady_tick(Duration::from_millis(300)); Some(pb) + } else if let Some(ref state) = spinner_state_for_task { + let mut state = state.lock().unwrap(); + if state.should_expand() { + let multi = state.expand().clone(); + let pb = multi.add( + ProgressBar::new(1) + .with_prefix( + format!( + "{: = threshold { - // SUCCESS_THRESHOLD reached, switch to short timeout tokio::time::sleep(Duration::from_secs(short_timeout())).await; return "short"; } - // Check if long timeout has expired if tokio::time::Instant::now() >= long_timeout_end { return "long"; } - // Sleep briefly before checking again tokio::time::sleep(check_interval).await; } }; @@ -546,11 +618,9 @@ impl Connect for Client { let result = tokio::select! { result = &mut fetch_future => { if result.is_ok() { - // Increment success count let new_count = success_count_clone.fetch_add(1, Ordering::Relaxed) + 1; let threshold = (total_relays_clone as f64 * SUCCESS_THRESHOLD).ceil() as u64; - // If we've reached SUCCESS_THRESHOLD, update timeout display if new_count >= threshold { current_timeout_clone.store(short_timeout(), Ordering::Relaxed); } @@ -565,7 +635,6 @@ impl Connect for Client { match result { Err(error) => { - // Check error for timeout/connection issues and add to skip list if error.to_string().contains("connection timeout") || error.to_string().contains("timeout after") { self.skip_relay_for_session(relay_url.clone(), error.to_string()); } @@ -619,6 +688,12 @@ impl Connect for Client { set }; } + + if let Some(ref state) = spinner_state { + let has_errors = relay_reports.iter().any(Result::is_err); + state.lock().unwrap().finish(has_errors); + } + Ok((relay_reports, progress_reporter)) } @@ -2084,8 +2159,11 @@ pub async fn fetching_with_report( #[cfg(not(test))] client: &Client, trusted_maintainer_coordinate: &Nip19Coordinate, ) -> Result { - let term = console::Term::stderr(); - term.write_line("fetching updates...")?; + let verbose = is_verbose(); + if verbose { + let term = console::Term::stderr(); + term.write_line("fetching updates...")?; + } let (relay_reports, progress_reporter) = client .fetch_all( Some(git_repo_path), diff --git a/src/lib/list.rs b/src/lib/list.rs index ce8737c..3b37b37 100644 --- a/src/lib/list.rs +++ b/src/lib/list.rs @@ -3,10 +3,10 @@ use std::{ path::PathBuf, str::FromStr, sync::{ - Arc, + Arc, Mutex, atomic::{AtomicU64, Ordering}, }, - time::Duration, + time::{Duration, Instant}, }; use anyhow::{Result, anyhow}; @@ -16,6 +16,7 @@ use indicatif::{MultiProgress, ProgressBar, ProgressState, ProgressStyle}; use nostr::hashes::sha1::Hash as Sha1Hash; use crate::{ + client::is_verbose, git::{ Repo, RepoActions, nostr_url::{CloneUrl, NostrUrlDecoded, ServerProtocol}, @@ -28,6 +29,61 @@ use crate::{ }, }; +const SPINNER_EXPAND_DELAY_SECS: u64 = 5; + +struct GitSpinnerState { + spinner: ProgressBar, + start_time: Instant, + expanded_multi: Option, +} + +impl GitSpinnerState { + fn new() -> Self { + let multi_progress = MultiProgress::new(); + let spinner = multi_progress.add( + ProgressBar::new_spinner() + .with_style( + ProgressStyle::with_template("{spinner} {msg}") + .unwrap() + .tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈"), + ) + .with_message("Checking git servers..."), + ); + spinner.enable_steady_tick(Duration::from_millis(100)); + Self { + spinner, + start_time: Instant::now(), + expanded_multi: None, + } + } + + fn should_expand(&self) -> bool { + self.expanded_multi.is_none() + && self.start_time.elapsed().as_secs() >= SPINNER_EXPAND_DELAY_SECS + } + + fn expand(&mut self) -> &MultiProgress { + if self.expanded_multi.is_none() { + self.spinner.finish_and_clear(); + self.expanded_multi = Some(MultiProgress::new()); + } + self.expanded_multi.as_ref().unwrap() + } + + fn finish(&self, has_errors: bool) { + if has_errors { + if let Some(ref multi) = self.expanded_multi { + let _ = multi.clear(); + } + } else { + self.spinner.finish_and_clear(); + if let Some(ref multi) = self.expanded_multi { + let _ = multi.clear(); + } + } + } +} + /// Sync issues identified for a single remote #[derive(Default, Debug, Clone)] pub struct RemoteIssues { @@ -111,18 +167,18 @@ pub async fn list_from_remotes( return HashMap::new(); } - let progress_reporter = if std::env::var("NGITTEST").is_err() { - MultiProgress::new() + let verbose = is_verbose(); + let spinner_state = if !verbose { + Some(Arc::new(Mutex::new(GitSpinnerState::new()))) } else { - MultiProgress::with_draw_target(indicatif::ProgressDrawTarget::hidden()) + None }; + let progress_reporter = MultiProgress::new(); - // Track successful servers for adaptive timeout let success_count = Arc::new(AtomicU64::new(0)); let current_timeout = Arc::new(AtomicU64::new(git_server_long_timeout())); let total_servers = git_servers.len() as u64; - // Calculate column width for alignment let server_column_width = git_servers .iter() .map(|s| get_short_git_server_name(s).chars().count()) @@ -139,11 +195,13 @@ pub async fn list_from_remotes( let current_timeout_clone = current_timeout.clone(); let progress_reporter_clone = progress_reporter.clone(); let decoded_nostr_url = decoded_nostr_url.clone(); + let spinner_state_clone = spinner_state.clone(); + let verbose_for_task = verbose; async move { let server_name = get_short_git_server_name(&url); - let pb = if std::env::var("NGITTEST").is_err() { + let pb = if verbose_for_task { match git_server_pb_style(current_timeout_clone.clone()) { Ok(style) => { let pb = progress_reporter_clone.add( @@ -164,6 +222,28 @@ pub async fn list_from_remotes( } Err(_) => None, } + } else if let Some(ref spinner_state_arc) = spinner_state_clone { + let mut state = spinner_state_arc.lock().unwrap(); + if state.should_expand() { + let multi = state.expand().clone(); + let pb = multi.add( + ProgressBar::new(1) + .with_prefix( + console::style(format!( + "{: Repo::from_path(&path).ok(), None => None, @@ -274,11 +352,9 @@ pub async fn list_from_remotes( Err((url, error)) } Ok(state) => { - // Determine sync status message and styling using existing functions let status_msg = if state.is_empty() { "empty repository".to_string() } else if let Some(nostr_state) = nostr_state { - // Use existing generate_remote_sync_warnings to get detailed status let mut temp_states = HashMap::new(); temp_states.insert(url.clone(), (state.clone(), is_grasp_server)); let remote_issues = identify_remote_sync_issues(git_repo, nostr_state, &temp_states); @@ -287,7 +363,6 @@ pub async fn list_from_remotes( if warnings.is_empty() { "in sync".to_string() } else { - // Extract the message after "WARNING: " let warning = &warnings[0]; let server_name = get_short_git_server_name(&url); let prefix = format!("WARNING: {} ", server_name); @@ -296,7 +371,6 @@ pub async fn list_from_remotes( .to_string() } } else { - // No nostr state to compare against "success".to_string() }; @@ -333,20 +407,22 @@ pub async fn list_from_remotes( .await; let mut remote_states = HashMap::new(); - let mut all_succeeded = true; + let mut has_errors = false; for result in results { match result { Ok((url, state, is_grasp_server)) => { remote_states.insert(url, (state, is_grasp_server)); } Err((url, error)) => { - all_succeeded = false; + has_errors = true; let _ = term.write_line(&format!("failed to list from {}: {}", url, error)); } } } - if all_succeeded { + if let Some(ref spinner_state_arc) = spinner_state { + spinner_state_arc.lock().unwrap().finish(has_errors); + } else if !has_errors { let _ = progress_reporter.clear(); } -- cgit v1.2.3