Indicate to the user that a stash save is in progress

asyncgit/src/lib.rs

@@ -39,6 +39,7 @@ mod push_tags;
 pub mod remote_progress;
 pub mod remote_tags;
 mod revlog;
+mod stash;
 mod status;
 pub mod sync;
 mod tags;
@@ -57,6 +58,7 @@ pub use crate::{
 	push_tags::{AsyncPushTags, PushTagsRequest},
 	remote_progress::{RemoteProgress, RemoteProgressState},
 	revlog::{AsyncLog, FetchStatus},
+	stash::AsyncStash,
 	status::{AsyncStatus, StatusParams},
 	sync::{
 		diff::{DiffLine, DiffLineType, FileDiff},
@@ -78,6 +80,8 @@ pub enum AsyncGitNotification {
 	/// this indicates that no new state was fetched but that a async process finished
 	FinishUnchanged,
 	///
+	Stash,
+	///
 	Status,
 	///
 	Diff,

asyncgit/src/stash.rs

@@ -0,0 +1,77 @@
+use crate::{
+	error::Result,
+	sync::{self, CommitId, RepoPath},
+	AsyncGitNotification,
+};
+use crossbeam_channel::Sender;
+use std::{
+	sync::atomic::{AtomicUsize, Ordering},
+	sync::Arc,
+};
+
+///
+pub struct AsyncStash {
+	pending: Arc<AtomicUsize>,
+	sender: Sender<AsyncGitNotification>,
+	repo: RepoPath,
+}
+
+impl AsyncStash {
+	///
+	pub fn new(
+		repo: RepoPath,
+		sender: Sender<AsyncGitNotification>,
+	) -> Self {
+		Self {
+			repo,
+			sender,
+			pending: Arc::new(AtomicUsize::new(0)),
+		}
+	}
+
+	///
+	pub fn stash_save(
+		&mut self,
+		message: Option<&str>,
+		include_untracked: bool,
+		keep_index: bool,
+	) -> Result<Option<CommitId>> {
+		if self.is_pending() {
+			log::trace!("request blocked, still pending");
+			return Ok(None);
+		}
+
+		let repo = self.repo.clone();
+		let sender = self.sender.clone();
+		let pending = self.pending.clone();
+		let message = message.map(ToOwned::to_owned);
+
+		self.pending.fetch_add(1, Ordering::Relaxed);
+
+		rayon_core::spawn(move || {
+			let res = sync::stash::stash_save(
+				&repo,
+				message.as_deref(),
+				include_untracked,
+				keep_index,
+			);
+
+			pending.fetch_sub(1, Ordering::Relaxed);
+
+			sender
+				.send(AsyncGitNotification::Stash)
+				.expect("error sending stash notification");
+
+			if let Err(e) = res {
+				log::error!("AsyncStash error: {}", e);
+			}
+		});
+
+		Ok(None)
+	}
+
+	///
+	pub fn is_pending(&self) -> bool {
+		self.pending.load(Ordering::Relaxed) > 0
+	}
+}

asyncgit/src/sync/mod.rs

@@ -25,7 +25,7 @@ mod repository;
 mod reset;
 mod reword;
 mod staging;
-mod stash;
+pub mod stash;
 mod state;
 pub mod status;
 mod submodules;

asyncgit/src/sync/stash.rs

@@ -1,3 +1,5 @@
+//! sync git api for stash
+
 use super::{CommitId, RepoPath};
 use crate::{
 	error::{Error, Result},

src/app.rs

@@ -169,8 +169,9 @@ impl App {
 				key_config.clone(),
 			),
 			stashmsg_popup: StashMsgComponent::new(
-				repo.clone(),
+				&repo,
 				queue.clone(),
+				sender,
 				theme.clone(),
 				key_config.clone(),
 			),
@@ -514,6 +515,7 @@ impl App {
 		if let AsyncNotification::Git(ev) = ev {
 			self.status_tab.update_git(ev)?;
 			self.stashing_tab.update_git(ev)?;
+			self.stashmsg_popup.update_git(ev);
 			self.revlog.update_git(ev)?;
 			self.blame_file_popup.update_git(ev)?;
 			self.file_revlog_popup.update_git(ev)?;
@@ -553,6 +555,7 @@ impl App {
 		self.status_tab.anything_pending()
 			|| self.revlog.any_work_pending()
 			|| self.stashing_tab.anything_pending()
+			|| self.stashmsg_popup.anything_pending()
 			|| self.files_tab.anything_pending()
 			|| self.blame_file_popup.any_work_pending()
 			|| self.file_revlog_popup.any_work_pending()

src/components/stashmsg.rs

@@ -6,19 +6,20 @@ use super::{
 use crate::{
 	keys::{key_match, SharedKeyConfig},
 	queue::{InternalEvent, NeedsUpdate, Queue},
-	strings,
+	strings::{self},
 	tabs::StashingOptions,
 	ui::style::SharedTheme,
 };
 use anyhow::Result;
-use asyncgit::sync::{self, RepoPathRef};
+use asyncgit::{sync::RepoPathRef, AsyncGitNotification, AsyncStash};
+use crossbeam_channel::Sender;
 use crossterm::event::Event;
 use ratatui::{backend::Backend, layout::Rect, Frame};
 
 pub struct StashMsgComponent {
-	repo: RepoPathRef,
 	options: StashingOptions,
 	input: TextInputComponent,
+	git_stash: AsyncStash,
 	queue: Queue,
 	key_config: SharedKeyConfig,
 }
@@ -64,40 +65,21 @@ impl Component for StashMsgComponent {
 
 			if let Event::Key(e) = ev {
 				if key_match(e, self.key_config.keys.enter) {
-					let result = sync::stash_save(
-						&self.repo.borrow(),
+					self.input.disable();
+					self.input.set_title(
+						strings::stash_popup_stashing(
+							&self.key_config,
+						),
+					);
+					self.git_stash.stash_save(
 						if self.input.get_text().is_empty() {
 							None
 						} else {
 							Some(self.input.get_text())
 						},
 						self.options.stash_untracked,
 						self.options.keep_index,
-					);
-					match result {
-						Ok(_) => {
-							self.input.clear();
-							self.hide();
-
-							self.queue.push(InternalEvent::Update(
-								NeedsUpdate::ALL,
-							));
-						}
-						Err(e) => {
-							self.hide();
-							log::error!(
-								"e: {} (options: {:?})",
-								e,
-								self.options
-							);
-							self.queue.push(
-                                InternalEvent::ShowErrorMsg(format!(
-                                    "stash error:\n{}\noptions:\n{:?}",
-                                    e, self.options
-                                )),
-                            );
-						}
-					}
+					)?;
 				}
 
 				// stop key event propagation
@@ -125,8 +107,9 @@ impl Component for StashMsgComponent {
 impl StashMsgComponent {
 	///
 	pub fn new(
-		repo: RepoPathRef,
+		repo: &RepoPathRef,
 		queue: Queue,
+		sender: &Sender<AsyncGitNotification>,
 		theme: SharedTheme,
 		key_config: SharedKeyConfig,
 	) -> Self {
@@ -141,12 +124,31 @@ impl StashMsgComponent {
 				true,
 			),
 			key_config,
-			repo,
+			git_stash: AsyncStash::new(
+				repo.borrow().clone(),
+				sender.clone(),
+			),
 		}
 	}
 
 	///
 	pub fn options(&mut self, options: StashingOptions) {
 		self.options = options;
 	}
+
+	///
+	pub fn anything_pending(&self) -> bool {
+		self.git_stash.is_pending()
+	}
+
+	///
+	pub fn update_git(&mut self, ev: AsyncGitNotification) {
+		if self.is_visible() && ev == AsyncGitNotification::Stash {
+			self.input.enable();
+			self.input.clear();
+			self.hide();
+
+			self.queue.push(InternalEvent::Update(NeedsUpdate::ALL));
+		}
+	}
 }

src/components/textinput.rs

@@ -31,11 +31,13 @@ pub enum InputType {
 }
 
 /// primarily a subcomponet for user input of text (used in `CommitComponent`)
+#[allow(clippy::struct_excessive_bools)]
 pub struct TextInputComponent {
 	title: String,
 	default_msg: String,
 	msg: String,
 	visible: bool,
+	disabled: bool,
 	show_char_count: bool,
 	theme: SharedTheme,
 	key_config: SharedKeyConfig,
@@ -57,6 +59,7 @@ impl TextInputComponent {
 		Self {
 			msg: String::new(),
 			visible: false,
+			disabled: false,
 			theme,
 			key_config,
 			show_char_count,
@@ -222,6 +225,16 @@ impl TextInputComponent {
 		self.default_msg = v;
 	}
 
+	///
+	pub fn disable(&mut self) {
+		self.disabled = true;
+	}
+
+	///
+	pub fn enable(&mut self) {
+		self.disabled = false;
+	}
+
 	fn get_draw_text(&self) -> Text {
 		let style = self.theme.text(true, false);
 
@@ -419,7 +432,7 @@ impl Component for TextInputComponent {
 	}
 
 	fn event(&mut self, ev: &Event) -> Result<EventState> {
-		if self.visible {
+		if self.visible && !self.disabled {
 			if let Event::Key(e) = ev {
 				if key_match(e, self.key_config.keys.exit_popup) {
 					self.hide();

src/strings.rs

@@ -138,6 +138,9 @@ pub fn stash_popup_title(_key_config: &SharedKeyConfig) -> String {
 pub fn stash_popup_msg(_key_config: &SharedKeyConfig) -> String {
 	"type name (optional)".to_string()
 }
+pub fn stash_popup_stashing(_key_config: &SharedKeyConfig) -> String {
+	"Stashing...".to_string()
+}
 pub fn confirm_title_reset() -> String {
 	"Reset".to_string()
 }