use crate::error::{Context, Result};
use super::objects::{object_path, Tree, TreeEntry, Commit};
use super::manager::{commit_tree_entries, AbsorbResult, VcsManager};
impl VcsManager {
pub async fn amend_commit(&self) -> Result<String> {
let index = self.repo.load_index()?;
let entries: Vec<TreeEntry> = index.entries_sorted().into_iter().map(|(path, blob_id)| {
TreeEntry { mode: 0o100644, name: path, id: blob_id }
}).collect();
let tree = Tree::new(entries);
let tree_id = self.repo.write_tree(&tree)?;
let head_id = self
.repo
.refs()
.resolve_head()?
.context("HEAD does not point to a commit")?;
let head_commit = self.repo.read_commit(&head_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let new_commit = Commit::new(
tree_id,
head_commit.parents.clone(),
head_commit.author.clone(),
head_commit.message.clone(),
timestamp,
);
let new_id = self.repo.write_commit(&new_commit)?;
if let Some(branch) = self.repo.refs().current_branch()? {
self.repo.refs().set_branch(&branch, &new_id)?;
}
Ok(new_id)
}
pub async fn reword(&self, commit_spec: &str, new_message: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
let new_message = new_message.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
let target_commit = repo.read_commit(&target_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let new_target = Commit::new(
target_commit.tree,
target_commit.parents.clone(),
target_commit.author.clone(),
new_message,
timestamp,
);
let new_target_id = repo.write_commit(&new_target)?;
let mut new_parent = new_target_id.clone();
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn squash(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
if target_commit.parents.is_empty() {
bail!("Cannot squash the root commit");
}
let parent_id = &target_commit.parents[0];
let parent_commit = repo.read_commit(parent_id)?;
let combined_message = if parent_commit.message == target_commit.message {
target_commit.message.clone()
} else {
format!("{}\n\n{}", parent_commit.message, target_commit.message)
};
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let squashed = Commit::new(
target_commit.tree,
parent_commit.parents.clone(),
parent_commit.author.clone(),
combined_message,
timestamp,
);
let squashed_id = repo.write_commit(&squashed)?;
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
let mut new_parent = squashed_id.clone();
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn move_commit(&self, commit_spec: &str, onto_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
let onto_spec = onto_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let new_parent_id = mgr.resolve_commit(&onto_spec, &head_id)?;
if target_id == new_parent_id {
bail!("Cannot move a commit onto itself");
}
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
if descendants.contains(&new_parent_id) {
bail!("Cannot move a commit onto one of its own descendants");
}
let target_commit = repo.read_commit(&target_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let moved = Commit::new(
target_commit.tree,
vec![new_parent_id.clone()],
target_commit.author.clone(),
target_commit.message.clone(),
timestamp,
);
let moved_id = repo.write_commit(&moved)?;
let mut new_parent = moved_id.clone();
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn unsquash(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
if target_commit.parents.is_empty() {
bail!("Cannot unsquash the root commit (no parent to split from)");
}
let parent_id = &target_commit.parents[0];
let parent_commit = repo.read_commit(parent_id)?;
if parent_commit.parents.is_empty() {
bail!("Cannot unsquash: parent commit is the root (no grandparent to restore)");
}
let grandparent_id = &parent_commit.parents[0];
let grandparent_commit = repo.read_commit(grandparent_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let restored_parent = Commit::new(
grandparent_commit.tree,
vec![grandparent_id.clone()],
parent_commit.author.clone(),
format!("{} (restored)", parent_commit.message),
timestamp,
);
let restored_id = repo.write_commit(&restored_parent)?;
let new_commit = Commit::new(
target_commit.tree,
vec![restored_id.clone()],
target_commit.author.clone(),
target_commit.message.clone(),
timestamp,
);
let new_commit_id = repo.write_commit(&new_commit)?;
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
let mut new_parent = new_commit_id.clone();
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let rebuilt = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&rebuilt)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn amend_to(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let head_tree = mgr.head_tree()?;
let head_map: std::collections::HashMap<String, String> = head_tree
.entries.iter().map(|e| (e.name.clone(), e.id.clone())).collect();
let wt_files = mgr.walk_working_tree(&repo_path)?;
let mut wt_changes: Vec<(String, String)> = Vec::new();
for file in &wt_files {
let relative = file.strip_prefix(&repo_path).unwrap_or(file);
let relative_str = relative.to_string_lossy().to_string();
let content = std::fs::read(file)
.with_context(|| format!("amend --to: read file {:?}", file))?;
let blob_id = repo.write_blob(&content)?;
match head_map.get(&relative_str) {
Some(h) if *h == blob_id => {} _ => wt_changes.push((relative_str, blob_id)),
}
}
if wt_changes.is_empty() {
bail!("No uncommitted changes to amend");
}
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
let is_head = current == target_id;
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
let target_commit = repo.read_commit(&target_id)?;
let target_tree = repo.read_tree(&target_commit.tree)?;
let mut target_entries = target_tree.entries.clone();
let target_map: std::collections::HashMap<String, usize> = target_tree
.entries.iter().enumerate().map(|(i, e)| (e.name.clone(), i)).collect();
let mut amended_files = Vec::new();
for (path, new_blob) in &wt_changes {
if let Some(&idx) = target_map.get(path) {
if new_blob.is_empty() {
target_entries[idx] = TreeEntry { mode: 0, name: String::new(), id: String::new() };
} else {
target_entries[idx].id = new_blob.clone();
}
amended_files.push(path.clone());
} else if !new_blob.is_empty() && is_head {
target_entries.push(TreeEntry { mode: 0o100644, name: path.clone(), id: new_blob.clone() });
amended_files.push(path.clone());
}
}
target_entries.retain(|e| e.mode != 0);
let new_tree = Tree::new(target_entries);
let new_tree_id = repo.write_tree(&new_tree)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let new_target = Commit::new(
new_tree_id,
target_commit.parents.clone(),
target_commit.author.clone(),
target_commit.message.clone(),
timestamp,
);
let new_target_id = repo.write_commit(&new_target)?;
let amended_set: std::collections::HashSet<&str> =
amended_files.iter().map(|s| s.as_str()).collect();
let mut new_parent = new_target_id.clone();
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let old_tree = repo.read_tree(&old_commit.tree)?;
let mut new_entries = old_tree.entries.clone();
for entry in &mut new_entries {
if amended_set.contains(entry.name.as_str())
&& let Some(blob) = wt_changes.iter().find(|(p, _)| p == &entry.name).map(|(_, b)| b)
&& !blob.is_empty()
{
entry.id = blob.clone();
}
}
let new_tree = Tree::new(new_entries);
let new_tree_id = repo.write_tree(&new_tree)?;
let new_commit = Commit::new(
new_tree_id,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn squash_into(&self, into_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let into_spec = into_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&into_spec, &head_id)?;
if target_id == head_id {
bail!("Cannot squash HEAD into itself");
}
let head_commit = repo.read_commit(&head_id)?;
let target_commit = repo.read_commit(&target_id)?;
let combined_message = if target_commit.message == head_commit.message {
head_commit.message.clone()
} else {
format!("{}\n\n{}", target_commit.message, head_commit.message)
};
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let squashed = Commit::new(
head_commit.tree,
target_commit.parents.clone(),
target_commit.author.clone(),
combined_message,
timestamp,
);
let squashed_id = repo.write_commit(&squashed)?;
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &into_spec);
}
current = commit.parents[0].clone();
}
let mut new_parent = squashed_id.clone();
for old_hash in descendants.iter().rev().skip(1) {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn revive(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let revived = Commit::new(
target_commit.tree,
vec![head_id.clone()],
target_commit.author.clone(),
target_commit.message.clone(),
timestamp,
);
let new_id = repo.write_commit(&revived)?;
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_id)?;
}
mgr.sync_index_to_commit(&new_id)?;
mgr.restore_working_tree_pub(&new_id)?;
Ok(new_id)
})
.await?
}
pub async fn duplicate(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let duplicated = Commit::new(
target_commit.tree,
vec![head_id.clone()],
target_commit.author.clone(),
format!("{} (duplicated)", target_commit.message),
timestamp,
);
let new_id = repo.write_commit(&duplicated)?;
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_id)?;
}
mgr.sync_index_to_commit(&new_id)?;
mgr.restore_working_tree_pub(&new_id)?;
Ok(new_id)
})
.await?
}
pub async fn abandon(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
if target_commit.parents.is_empty() {
bail!("Cannot abandon the root commit");
}
let new_parent_id = target_commit.parents[0].clone();
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == target_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &commit_spec);
}
current = commit.parents[0].clone();
}
if descendants.is_empty() {
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent_id)?;
}
mgr.sync_index_to_commit(&new_parent_id)?;
mgr.restore_working_tree_pub(&new_parent_id)?;
return Ok(new_parent_id);
}
let mut new_parent = new_parent_id;
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
pub async fn forget(&self, commit_spec: &str) -> Result<String> {
let new_head = self.abandon(commit_spec).await?;
let head_id = self.repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = self.resolve_commit_pub(commit_spec, &head_id)?;
let commit_path = object_path(self.repo.root(), &target_id);
if commit_path.exists() {
let _ = std::fs::remove_file(&commit_path);
}
Ok(new_head)
}
pub async fn fold(&self, from_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let from_spec = from_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let from_id = mgr.resolve_commit(&from_spec, &head_id)?;
if from_id == head_id {
bail!("Cannot fold a single commit (from == HEAD)");
}
let mut commits_in_range: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
commits_in_range.push(current.clone());
if current == from_id {
break;
}
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", &from_spec);
}
current = commit.parents[0].clone();
}
let from_commit = repo.read_commit(&from_id)?;
if from_commit.parents.is_empty() {
bail!("Cannot fold from the root commit");
}
let new_parent_id = &from_commit.parents[0];
let mut messages: Vec<String> = Vec::new();
for hash in commits_in_range.iter().rev() {
let commit = repo.read_commit(hash)?;
messages.push(commit.message.clone());
}
let combined_message = messages.join("\n\n");
let head_commit = repo.read_commit(&head_id)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let folded = Commit::new(
head_commit.tree,
vec![new_parent_id.clone()],
head_commit.author.clone(),
combined_message,
timestamp,
);
let folded_id = repo.write_commit(&folded)?;
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &folded_id)?;
}
mgr.sync_index_to_commit(&folded_id)?;
mgr.restore_working_tree_pub(&folded_id)?;
Ok(folded_id)
})
.await?
}
pub async fn revert(&self, commit_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let commit_spec = commit_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let target_id = mgr.resolve_commit(&commit_spec, &head_id)?;
let target_commit = repo.read_commit(&target_id)?;
if target_commit.parents.is_empty() {
bail!("Cannot revert the root commit");
}
let parent_id = &target_commit.parents[0];
let parent_commit = repo.read_commit(parent_id)?;
let base_tree = repo.read_tree(&target_commit.tree)?;
let our_tree = mgr.head_tree()?;
let their_tree = repo.read_tree(&parent_commit.tree)?;
let (merged_entries, conflicts) = mgr.merge_trees(&base_tree, &our_tree, &their_tree)?;
if !conflicts.is_empty() {
let conflict_files: Vec<_> = conflicts.iter().map(|c| c.path.clone()).collect();
bail!("Revert conflicts in: {}. Resolve manually.", conflict_files.join(", "));
}
let new_tree = Tree::new(merged_entries);
let new_tree_id = repo.write_tree(&new_tree)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let message = format!("Revert \"{}\"", target_commit.message.lines().next().unwrap_or(""));
let new_commit = Commit::new(
new_tree_id,
vec![head_id.clone()],
target_commit.author.clone(),
message,
timestamp,
);
let new_id = repo.write_commit(&new_commit)?;
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_id)?;
}
mgr.sync_index_to_commit(&new_id)?;
mgr.restore_working_tree_pub(&new_id)?;
Ok(new_id)
})
.await?
}
pub async fn absorb(&self) -> Result<AbsorbResult> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
tokio::task::spawn_blocking(move || -> Result<AbsorbResult> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_tree = mgr.head_tree()?;
let head_map: std::collections::HashMap<String, String> = head_tree
.entries
.iter()
.map(|e| (e.name.clone(), e.id.clone()))
.collect();
let wt_files = mgr.walk_working_tree(&repo_path)?;
let mut wt_changes: Vec<(String, String)> = Vec::new(); for file in &wt_files {
let relative = file.strip_prefix(&repo_path).unwrap_or(file);
let relative_str = relative.to_string_lossy().to_string();
let content = std::fs::read(file)
.with_context(|| format!("absorb: read wt file {:?}", file))?;
let blob_id = repo.write_blob(&content)?;
match head_map.get(&relative_str) {
Some(h) if *h == blob_id => {} _ => wt_changes.push((relative_str, blob_id)),
}
}
let wt_set: std::collections::HashSet<&str> =
wt_files.iter().map(|f| f.strip_prefix(&repo_path).unwrap_or(f).to_str().unwrap()).collect();
for name in head_map.keys() {
if !wt_set.contains(name.as_str()) {
wt_changes.push((name.clone(), String::new())); }
}
if wt_changes.is_empty() {
bail!("No uncommitted changes to absorb");
}
let wt_files_set: std::collections::HashSet<&str> =
wt_changes.iter().map(|(p, _)| p.as_str()).collect();
let head_id = repo.refs().resolve_head()?.context("HEAD does not point to a commit")?;
let mut commits: Vec<(String, Vec<String>)> = Vec::new();
let mut current = head_id.clone();
for _ in 0..50 {
let commit = repo.read_commit(¤t)?;
let parent_tree = if !commit.parents.is_empty() {
let parent = repo.read_commit(&commit.parents[0])?;
repo.read_tree(&parent.tree)?
} else {
Tree::new(vec![])
};
let changed: Vec<String> = {
let parent_set: std::collections::HashMap<&String, &String> = parent_tree
.entries.iter().map(|e| (&e.name, &e.id)).collect();
let mut files = Vec::new();
for entry in &commit_tree_entries(&repo, ¤t)? {
match parent_set.get(&entry.name) {
Some(h) if **h != entry.id => files.push(entry.name.clone()),
None => files.push(entry.name.clone()),
_ => {}
}
}
for name in parent_tree.entries.iter().map(|e| &e.name) {
if !commit_tree_entries(&repo, ¤t)?.iter().any(|e| &e.name == name) {
files.push(name.clone());
}
}
files
};
commits.push((current.clone(), changed));
if commit.parents.is_empty() {
break;
}
current = commit.parents[0].clone();
}
let mut best_idx = 0usize;
let mut best_overlap = 0usize;
for (i, (_, changed)) in commits.iter().enumerate() {
let overlap = changed.iter().filter(|f| wt_files_set.contains(f.as_str())).count();
if overlap > best_overlap {
best_overlap = overlap;
best_idx = i;
}
}
if best_overlap == 0 {
best_idx = 0;
}
let (target_hash, _) = &commits[best_idx];
let target_hash = target_hash.clone();
let target_commit = repo.read_commit(&target_hash)?;
let target_tree = repo.read_tree(&target_commit.tree)?;
let mut target_entries: Vec<TreeEntry> = target_tree.entries.clone();
let target_map: std::collections::HashMap<String, usize> = target_tree
.entries.iter().enumerate().map(|(i, e)| (e.name.clone(), i)).collect();
let mut absorbed_files = Vec::new();
for (path, new_blob) in &wt_changes {
if let Some(&idx) = target_map.get(path) {
if new_blob.is_empty() {
target_entries[idx] = TreeEntry { mode: 0, name: String::new(), id: String::new() };
} else {
target_entries[idx].id = new_blob.clone();
}
absorbed_files.push(path.clone());
} else if !new_blob.is_empty() {
if best_idx == 0 {
target_entries.push(TreeEntry { mode: 0o100644, name: path.clone(), id: new_blob.clone() });
absorbed_files.push(path.clone());
}
}
}
target_entries.retain(|e| e.mode != 0);
let new_target_tree = Tree::new(target_entries);
let new_target_tree_id = repo.write_tree(&new_target_tree)?;
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
let new_target_commit = Commit::new(
new_target_tree_id,
target_commit.parents.clone(),
target_commit.author.clone(),
target_commit.message.clone(),
timestamp,
);
let new_target_id = repo.write_commit(&new_target_commit)?;
let mut new_parent = new_target_id.clone();
let absorbed_set: std::collections::HashSet<&str> =
absorbed_files.iter().map(|s| s.as_str()).collect();
for i in (0..best_idx).rev() {
let (old_hash, _) = &commits[i];
let old_commit = repo.read_commit(old_hash)?;
let old_tree = repo.read_tree(&old_commit.tree)?;
let mut new_entries = old_tree.entries.clone();
let old_tree_map: std::collections::HashMap<String, usize> = old_tree
.entries.iter().enumerate().map(|(i, e)| (e.name.clone(), i)).collect();
for (path, new_blob) in &wt_changes {
if !absorbed_set.contains(path.as_str()) {
continue;
}
if let Some(&idx) = old_tree_map.get(path) {
let target_blob = target_tree.entries.iter()
.find(|e| e.name == *path)
.map(|e| e.id.clone());
if old_tree.entries[idx].id == target_blob.unwrap_or_default() {
if new_blob.is_empty() {
new_entries[idx] = TreeEntry { mode: 0, name: String::new(), id: String::new() };
} else {
new_entries[idx].id = new_blob.clone();
}
}
}
}
new_entries.retain(|e| e.mode != 0);
let new_tree = Tree::new(new_entries);
let new_tree_id = repo.write_tree(&new_tree)?;
let new_commit = Commit::new(
new_tree_id,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
let branch = repo.refs().current_branch()?.context("No current branch")?;
repo.refs().set_branch(&branch, &new_parent)?;
let mgr2 = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
mgr2.sync_index_to_commit(&new_parent)
.context("absorb: sync index")?;
mgr2.restore_working_tree_pub(&new_parent)
.context("absorb: restore working tree")?;
Ok(AbsorbResult {
new_head: new_parent,
target_commit: target_hash,
absorbed_files,
was_head: best_idx == 0,
})
})
.await?
}
pub async fn reset_soft_parent(&self) -> Result<()> {
let head_id = self
.repo
.refs()
.resolve_head()?
.context("HEAD does not point to a commit")?;
let head_commit = self.repo.read_commit(&head_id)?;
if head_commit.parents.is_empty() {
bail!("No parent commit to reset to");
}
let parent_id = &head_commit.parents[0];
if let Some(branch) = self.repo.refs().current_branch()? {
self.repo.refs().set_branch(&branch, parent_id)?;
}
let parent_commit = self.repo.read_commit(parent_id)?;
let tree = self.repo.read_tree(&parent_commit.tree)?;
let mut index = self.repo.load_index()?;
index.clear();
for entry in &tree.entries {
index.add(&entry.name, &entry.id);
}
index.save()?;
Ok(())
}
pub async fn restore(&self, from_spec: &str, to_spec: &str) -> Result<String> {
let repo = self.repo.clone();
let repo_path = self.repo_path.clone();
let from_spec = from_spec.to_string();
let to_spec = to_spec.to_string();
tokio::task::spawn_blocking(move || -> Result<String> {
let mgr = VcsManager { repo: repo.clone(), repo_path: repo_path.clone(), max_file_size: 0 };
let head_id = repo.refs().resolve_head()?
.context("HEAD does not point to a commit")?;
let from_id = mgr.resolve_commit(&from_spec, &head_id)?;
let to_id = mgr.resolve_commit(&to_spec, &head_id)?;
let from_commit = repo.read_commit(&from_id)?;
let to_commit = repo.read_commit(&to_id)?;
let restored = Commit::new(
from_commit.tree,
to_commit.parents.clone(),
to_commit.author.clone(),
to_commit.message.clone(),
to_commit.timestamp,
);
let new_to_id = repo.write_commit(&restored)?;
let mut descendants: Vec<String> = Vec::new();
let mut current = head_id.clone();
loop {
if current == to_id {
break;
}
descendants.push(current.clone());
let commit = repo.read_commit(¤t)?;
if commit.parents.is_empty() {
bail!("Commit {} is not an ancestor of HEAD", to_spec);
}
current = commit.parents[0].clone();
}
let mut new_parent = new_to_id;
for old_hash in descendants.iter().rev() {
let old_commit = repo.read_commit(old_hash)?;
let new_commit = Commit::new(
old_commit.tree,
vec![new_parent.clone()],
old_commit.author.clone(),
old_commit.message.clone(),
old_commit.timestamp,
);
new_parent = repo.write_commit(&new_commit)?;
}
if let Some(branch) = repo.refs().current_branch()? {
repo.refs().set_branch(&branch, &new_parent)?;
}
mgr.sync_index_to_commit(&new_parent)?;
mgr.restore_working_tree_pub(&new_parent)?;
Ok(new_parent)
})
.await?
}
}