rebase state

Author: Stephan Dilly

asyncgit/src/sync/merge.rs

@@ -1,14 +1,15 @@
 use crate::{
 	error::{Error, Result},
 	sync::{
-		branch::merge_commit::commit_merge_with_head, reset_stage,
-		reset_workdir, utils, CommitId,
+		branch::merge_commit::commit_merge_with_head,
+		rebase::get_rebase_progress, reset_stage, reset_workdir,
+		utils, CommitId,
 	},
 };
 use git2::{BranchType, Commit, MergeOptions, Repository};
 use scopetime::scope_time;
 
-use super::rebase::conflict_free_rebase;
+use super::rebase::{rebase, RebaseProgress, RebaseState};
 
 ///
 pub fn mergehead_ids(repo_path: &str) -> Result<Vec<CommitId>> {
@@ -57,14 +58,23 @@ pub fn merge_branch(repo_path: &str, branch: &str) -> Result<()> {
 pub fn rebase_branch(
 	repo_path: &str,
 	branch: &str,
-) -> Result<CommitId> {
+) -> Result<RebaseState> {
 	scope_time!("rebase_branch");
 
 	let repo = utils::repo(repo_path)?;
 
 	rebase_branch_repo(&repo, branch)
 }
 
+///
+pub fn rebase_progress(repo_path: &str) -> Result<RebaseProgress> {
+	scope_time!("rebase_progress");
+
+	let repo = utils::repo(repo_path)?;
+
+	get_rebase_progress(&repo)
+}
+
 ///
 pub fn merge_branch_repo(
 	repo: &Repository,
@@ -93,13 +103,13 @@ pub fn merge_branch_repo(
 pub fn rebase_branch_repo(
 	repo: &Repository,
 	branch_name: &str,
-) -> Result<CommitId> {
+) -> Result<RebaseState> {
 	let branch = repo.find_branch(branch_name, BranchType::Local)?;
 
 	let annotated =
 		repo.reference_to_annotated_commit(&branch.into_reference())?;
 
-	conflict_free_rebase(repo, &annotated)
+	rebase(repo, &annotated)
 }
 
 ///

asyncgit/src/sync/mod.rs

@@ -59,7 +59,7 @@ pub use ignore::add_to_ignore;
 pub use logwalker::{LogWalker, LogWalkerFilter};
 pub use merge::{
 	abort_merge, merge_branch, merge_commit, merge_msg,
-	mergehead_ids, rebase_branch,
+	mergehead_ids, rebase_branch, rebase_progress,
 };
 pub use remotes::{
 	get_default_remote, get_remotes, push::AsyncProgress,

asyncgit/src/sync/rebase.rs

@@ -37,14 +37,89 @@ pub fn conflict_free_rebase(
 	})
 }
 
+///
+#[derive(PartialEq, Debug)]
+pub enum RebaseState {
+	///
+	Finished,
+	///
+	Conflicted,
+}
+
+/// rebase
+#[allow(dead_code)]
+pub fn rebase(
+	repo: &git2::Repository,
+	commit: &git2::AnnotatedCommit,
+) -> Result<RebaseState> {
+	let mut rebase = repo.rebase(None, Some(commit), None, None)?;
+	let signature =
+		crate::sync::commit::signature_allow_undefined_name(repo)?;
+
+	while let Some(op) = rebase.next() {
+		let _op = op?;
+		// dbg!(op.id());
+
+		if repo.index()?.has_conflicts() {
+			return Ok(RebaseState::Conflicted);
+		}
+
+		rebase.commit(None, &signature, None)?;
+	}
+
+	if repo.index()?.has_conflicts() {
+		return Ok(RebaseState::Conflicted);
+	}
+
+	rebase.finish(Some(&signature))?;
+
+	Ok(RebaseState::Finished)
+}
+
+///
+#[derive(PartialEq, Debug)]
+pub struct RebaseProgress {
+	///
+	pub steps: usize,
+	///
+	pub current: usize,
+}
+
+///
+#[allow(dead_code)]
+pub fn get_rebase_progress(
+	repo: &git2::Repository,
+) -> Result<RebaseProgress> {
+	let mut rebase = repo.open_rebase(None)?;
+
+	let progress = RebaseProgress {
+		steps: rebase.len(),
+		current: rebase.operation_current().unwrap_or_default(),
+	};
+
+	Ok(progress)
+}
+
+///
+#[allow(dead_code)]
+pub fn abort_rebase(repo: &git2::Repository) -> Result<()> {
+	let mut rebase = repo.open_rebase(None)?;
+
+	rebase.abort()?;
+
+	Ok(())
+}
+
 #[cfg(test)]
-mod tests {
+mod test_conflict_free_rebase {
 	use crate::sync::{
-		checkout_branch, create_branch, rebase_branch, repo_state,
+		checkout_branch, create_branch,
+		rebase::{conflict_free_rebase, RebaseState},
+		rebase_branch, repo_state,
 		tests::{repo_init, write_commit_file},
-		CommitId, RepoState,
+		utils, CommitId, RepoState,
 	};
-	use git2::Repository;
+	use git2::{BranchType, Repository};
 
 	fn parent_ids(repo: &Repository, c: CommitId) -> Vec<CommitId> {
 		let foo = repo
@@ -57,6 +132,23 @@ mod tests {
 		foo
 	}
 
+	///
+	fn test_rebase_branch_repo(
+		repo_path: &str,
+		branch_name: &str,
+	) -> CommitId {
+		let repo = utils::repo(repo_path).unwrap();
+
+		let branch =
+			repo.find_branch(branch_name, BranchType::Local).unwrap();
+
+		let annotated = repo
+			.reference_to_annotated_commit(&branch.into_reference())
+			.unwrap();
+
+		conflict_free_rebase(&repo, &annotated).unwrap()
+	}
+
 	#[test]
 	fn test_smoke() {
 		let (_td, repo) = repo_init().unwrap();
@@ -80,7 +172,7 @@ mod tests {
 
 		checkout_branch(repo_path, "refs/heads/foo").unwrap();
 
-		let r = rebase_branch(repo_path, "master").unwrap();
+		let r = test_rebase_branch_repo(repo_path, "master");
 
 		assert_eq!(parent_ids(&repo, r), vec![c3]);
 	}
@@ -105,7 +197,62 @@ mod tests {
 
 		let res = rebase_branch(repo_path, "master");
 
-		assert!(res.is_err());
+		assert!(matches!(res.unwrap(), RebaseState::Conflicted));
+
+		assert_eq!(repo_state(repo_path).unwrap(), RepoState::Rebase);
+	}
+}
+
+#[cfg(test)]
+mod test_rebase {
+	use crate::sync::{
+		checkout_branch, create_branch,
+		rebase::{
+			abort_rebase, get_rebase_progress, RebaseProgress,
+			RebaseState,
+		},
+		rebase_branch, repo_state,
+		tests::{repo_init, write_commit_file},
+		RepoState,
+	};
+
+	#[test]
+	fn test_conflicted_abort() {
+		let (_td, repo) = repo_init().unwrap();
+		let root = repo.path().parent().unwrap();
+		let repo_path = root.as_os_str().to_str().unwrap();
+
+		write_commit_file(&repo, "test.txt", "test1", "commit1");
+
+		create_branch(repo_path, "foo").unwrap();
+
+		write_commit_file(&repo, "test.txt", "test2", "commit2");
+
+		checkout_branch(repo_path, "refs/heads/master").unwrap();
+
+		write_commit_file(&repo, "test.txt", "test3", "commit3");
+
+		checkout_branch(repo_path, "refs/heads/foo").unwrap();
+
+		assert!(get_rebase_progress(&repo).is_err());
+
+		// rebase
+
+		let r = rebase_branch(repo_path, "master").unwrap();
+
+		assert_eq!(r, RebaseState::Conflicted);
+		assert_eq!(repo_state(repo_path).unwrap(), RepoState::Rebase);
+		assert_eq!(
+			get_rebase_progress(&repo).unwrap(),
+			RebaseProgress {
+				current: 0,
+				steps: 1
+			}
+		);
+
+		// abort
+
+		abort_rebase(&repo).unwrap();
 
 		assert_eq!(repo_state(repo_path).unwrap(), RepoState::Clean);
 	}

asyncgit/src/sync/state.rs

@@ -10,6 +10,8 @@ pub enum RepoState {
 	///
 	Merge,
 	///
+	Rebase,
+	///
 	Other,
 }
 
@@ -18,6 +20,7 @@ impl From<RepositoryState> for RepoState {
 		match state {
 			RepositoryState::Clean => Self::Clean,
 			RepositoryState::Merge => Self::Merge,
+			RepositoryState::RebaseMerge => Self::Rebase,
 			_ => Self::Other,
 		}
 	}
@@ -29,5 +32,9 @@ pub fn repo_state(repo_path: &str) -> Result<RepoState> {
 
 	let repo = utils::repo(repo_path)?;
 
-	Ok(repo.state().into())
+	let state = repo.state();
+
+	// dbg!(&state);
+
+	Ok(state.into())
 }

src/tabs/status.rs

@@ -215,14 +215,12 @@ impl Status {
 		}
 	}
 
-	fn draw_repo_state<B: tui::backend::Backend>(
-		f: &mut tui::Frame<B>,
-		r: tui::layout::Rect,
-	) -> Result<()> {
-		if let Ok(state) = sync::repo_state(CWD) {
-			if state != RepoState::Clean {
+	fn repo_state_text(state: RepoState) -> String {
+		match state {
+			RepoState::Merge => {
 				let ids =
 					sync::mergehead_ids(CWD).unwrap_or_default();
+
 				let ids = format!(
 					"({})",
 					ids.iter()
@@ -231,7 +229,31 @@ impl Status {
 						))
 						.join(",")
 				);
-				let txt = format!("{:?} {}", state, ids);
+
+				format!("{:?} {}", state, ids)
+			}
+			RepoState::Rebase => {
+				let progress =
+					if let Ok(p) = sync::rebase_progress(CWD) {
+						format!("{}/{}", p.current + 1, p.steps)
+					} else {
+						String::new()
+					};
+
+				format!("{:?} ({})", state, progress)
+			}
+			_ => format!("{:?}", state),
+		}
+	}
+
+	fn draw_repo_state<B: tui::backend::Backend>(
+		f: &mut tui::Frame<B>,
+		r: tui::layout::Rect,
+	) -> Result<()> {
+		if let Ok(state) = sync::repo_state(CWD) {
+			if state != RepoState::Clean {
+				let txt = Self::repo_state_text(state);
+
 				let txt_len = u16::try_from(txt.len())?;
 				let w = Paragraph::new(txt)
 					.style(Style::default().fg(Color::Red))