use crate::error::{Context, Result};
use super::objects::{Tree, TreeEntry, Commit};
use super::manager::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, merge_drivers: std::collections::HashMap::new() };
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 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, merge_drivers: std::collections::HashMap::new() };
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 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, merge_drivers: std::collections::HashMap::new() };
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?
}
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, merge_drivers: std::collections::HashMap::new() };
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 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, merge_drivers: std::collections::HashMap::new() };
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?
}
}