fix conflicts

Author: Stephan Dilly

asyncgit/src/sync/merge.rs

@@ -2,14 +2,14 @@ use crate::{
 	error::{Error, Result},
 	sync::{
 		branch::merge_commit::commit_merge_with_head,
-		rebase::get_rebase_progress, reset_stage, reset_workdir,
-		utils, CommitId,
+		rebase::{continue_rebase, get_rebase_progress},
+		reset_stage, reset_workdir, utils, CommitId,
 	},
 };
 use git2::{BranchType, Commit, MergeOptions, Repository};
 use scopetime::scope_time;
 
-use super::rebase::RebaseProgress;
+use super::rebase::{RebaseProgress, RebaseState};
 
 ///
 pub fn mergehead_ids(repo_path: &str) -> Result<Vec<CommitId>> {
@@ -63,6 +63,17 @@ pub fn rebase_progress(repo_path: &str) -> Result<RebaseProgress> {
 	get_rebase_progress(&repo)
 }
 
+///
+pub fn continue_pending_rebase(
+	repo_path: &str,
+) -> Result<RebaseState> {
+	scope_time!("continue_pending_rebase");
+
+	let repo = utils::repo(repo_path)?;
+
+	continue_rebase(&repo)
+}
+
 ///
 pub fn merge_branch_repo(
 	repo: &Repository,

asyncgit/src/sync/mod.rs

@@ -58,8 +58,8 @@ pub use hunks::{reset_hunk, stage_hunk, unstage_hunk};
 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_progress,
+	abort_merge, continue_pending_rebase, merge_branch, merge_commit,
+	merge_msg, mergehead_ids, rebase_progress,
 };
 pub use rebase::rebase_branch;
 pub use remotes::{

asyncgit/src/sync/rebase.rs

@@ -76,8 +76,7 @@ pub enum RebaseState {
 }
 
 /// rebase
-#[allow(dead_code)]
-fn rebase(
+pub fn rebase(
 	repo: &git2::Repository,
 	commit: &git2::AnnotatedCommit,
 ) -> Result<RebaseState> {
@@ -105,6 +104,38 @@ fn rebase(
 	Ok(RebaseState::Finished)
 }
 
+/// continue pending rebase
+pub fn continue_rebase(
+	repo: &git2::Repository,
+) -> Result<RebaseState> {
+	if repo.index()?.has_conflicts() {
+		return Ok(RebaseState::Conflicted);
+	}
+
+	let mut rebase = repo.open_rebase(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 {
@@ -115,7 +146,6 @@ pub struct RebaseProgress {
 }
 
 ///
-#[allow(dead_code)]
 pub fn get_rebase_progress(
 	repo: &git2::Repository,
 ) -> Result<RebaseProgress> {

src/strings.rs

@@ -628,6 +628,19 @@ pub mod commands {
 			CMD_GROUP_GENERAL,
 		)
 	}
+
+	pub fn continue_rebase(
+		key_config: &SharedKeyConfig,
+	) -> CommandText {
+		CommandText::new(
+			format!(
+				"Continue rebase [{}]",
+				key_config.get_hint(key_config.rebase_branch),
+			),
+			"continue ongoing rebase",
+			CMD_GROUP_GENERAL,
+		)
+	}
 	pub fn select_staging(
 		key_config: &SharedKeyConfig,
 	) -> CommandText {

src/tabs/status.rs

@@ -541,10 +541,23 @@ impl Status {
 			== RepoState::Merge
 	}
 
+	fn pending_rebase() -> bool {
+		sync::repo_state(CWD).unwrap_or(RepoState::Clean)
+			== RepoState::Rebase
+	}
+
 	pub fn abort_merge(&self) {
 		try_or_popup!(self, "abort merge", sync::abort_merge(CWD));
 	}
 
+	fn continue_rebase(&self) {
+		try_or_popup!(
+			self,
+			"continue rebase",
+			sync::continue_pending_rebase(CWD)
+		);
+	}
+
 	fn commands_nav(
 		&self,
 		out: &mut Vec<CommandInfo>,
@@ -642,6 +655,11 @@ impl Component for Status {
 				true,
 				Self::can_abort_merge() || force_all,
 			));
+			out.push(CommandInfo::new(
+				strings::commands::continue_rebase(&self.key_config),
+				true,
+				Self::pending_rebase() || force_all,
+			));
 		}
 
 		{
@@ -747,6 +765,14 @@ impl Component for Status {
 						Action::AbortMerge,
 					));
 
+					Ok(EventState::Consumed)
+				} else if k == self.key_config.rebase_branch
+					&& Self::pending_rebase()
+				{
+					self.continue_rebase();
+					self.queue.push(InternalEvent::Update(
+						NeedsUpdate::ALL,
+					));
 					Ok(EventState::Consumed)
 				} else {
 					Ok(EventState::NotConsumed)