Construindo um Git do zero em Rust

[package]
name = "rastro"
version = "0.1.0"
edition = "2021"

[lib]
name = "rastro"
path = "src/lib.rs"

[[bin]]
name = "rastro"
path = "src/main.rs"

[dependencies]

pub mod blob;
pub mod checkout;
pub mod commit;
pub mod hash;
pub mod head;
pub mod index;
pub mod log;
pub mod merge;
pub mod object_store;
pub mod refs;
pub mod repository;
pub mod tree;

pub type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;

use rastro::{
    log, merge::MergeStrategy, refs,
    repository::{MergeOutcome, Repository},
    Result,
};
use std::{env, path::{Path, PathBuf}};

fn main() {
    if let Err(error) = run() {
        eprintln!("erro: {error}");
        std::process::exit(1);
    }
}

fn run() -> Result<()> {
    let mut args = env::args().skip(1);
    let command = args.next().ok_or("uso: rastro <comando>")?;
    if command == "init" {
        let path = args.next().unwrap_or_else(|| ".".into());
        let repository = Repository::init(Path::new(&path))?;
        println!("repositório criado em {}", repository.rastro_dir.display());
        return Ok(());
    }

    let repository = Repository::discover(&env::current_dir()?)?;
    match command.as_str() {
        "add" => {
            let paths: Vec<PathBuf> = args.map(PathBuf::from).collect();
            if paths.is_empty() {
                return Err("uso: rastro add <arquivo ou diretório>".into());
            }
            repository.add(&paths)?;
            println!("arquivos adicionados ao index");
        }
        "commit" => {
            if args.next().as_deref() != Some("-m") {
                return Err("uso: rastro commit -m \"mensagem\"".into());
            }
            let message = args.next().ok_or("mensagem ausente")?;
            let oid = repository.commit(&message)?;
            println!("[{}] {message}", &oid[..7]);
        }
        "log" => {
            let start = refs::resolve_head(&repository.rastro_dir)?;
            for (oid, commit) in log::collect(&repository.store, start)? {
                println!("commit {oid}");
                println!("Autor: {}", commit.author);
                println!("Data:  {}", log::format_timestamp(commit.timestamp));
                println!("\n    {}\n", commit.message);
            }
        }
        "status" => {
            let status = repository.status()?;
            print_group("Alterações preparadas", &status.staged);
            print_group("Alterações não preparadas", &status.modified);
            print_group("Arquivos não rastreados", &status.untracked);
            if status.staged.is_empty() && status.modified.is_empty() && status.untracked.is_empty() {
                println!("nada para fazer; diretório de trabalho limpo");
            }
        }
        "checkout" => {
            let target = args.next().ok_or("uso: rastro checkout <branch ou hash>")?;
            let oid = repository.checkout(&target)?;
            println!("arquivos restaurados a partir de {}", &oid[..7]);
        }
        "branch" => {
            match args.next().as_deref() {
                None => {
                    for (name, selected) in repository.list_branches()? {
                        println!("{} {name}", if selected { "*" } else { " " });
                    }
                }
                Some("-d") => {
                    let name = args.next().ok_or("uso: rastro branch -d <nome>")?;
                    repository.delete_branch(&name, false)?;
                    println!("branch {name} excluída");
                }
                Some("-D") => {
                    let name = args.next().ok_or("uso: rastro branch -D <nome>")?;
                    repository.delete_branch(&name, true)?;
                    println!("branch {name} excluída à força");
                }
                Some(name) => {
                    repository.create_branch(name)?;
                    println!("branch {name} criada");
                }
            }
        }
        "merge" => {
            let arguments: Vec<String> = args.collect();
            if arguments.len() == 1 && arguments[0] == "--abort" {
                repository.abort_merge()?;
                println!("merge abortado; arquivos restaurados");
                return Ok(());
            }
            if arguments.iter().filter(|arg| !arg.starts_with('-')).count() != 1 {
                return Err("uso: rastro merge <branch> [--ours|--theirs]".into());
            }
            let branch = arguments.iter().find(|arg| !arg.starts_with('-'))
                .ok_or("uso: rastro merge <branch> [--ours|--theirs]")?;
            if arguments.iter().any(|arg| {
                arg.starts_with('-') && arg != "--ours" && arg != "--theirs"
            }) {
                return Err("opção de merge desconhecida; use --ours, --theirs ou --abort".into());
            }
            if arguments.iter().any(|arg| arg == "--ours")
                && arguments.iter().any(|arg| arg == "--theirs")
            {
                return Err("escolha apenas uma estratégia: --ours ou --theirs".into());
            }
            let strategy = if arguments.iter().any(|arg| arg == "--ours") {
                MergeStrategy::Ours
            } else if arguments.iter().any(|arg| arg == "--theirs") {
                MergeStrategy::Theirs
            } else {
                MergeStrategy::Manual
            };
            match repository.merge(branch, strategy)? {
                MergeOutcome::AlreadyUpToDate => println!("já está atualizado"),
                MergeOutcome::FastForward(oid) => {
                    println!("fast-forward para {}", &oid[..7])
                }
                MergeOutcome::MergeCommit(oid) => {
                    println!("merge criado em {}", &oid[..7])
                }
                MergeOutcome::Conflicts(paths) => {
                    println!("conflitos encontrados:");
                    for path in paths {
                        println!("  {path}");
                    }
                    println!("edite os marcadores, use rastro add e finalize com rastro commit");
                }
            }
        }
        _ => return Err(format!("comando desconhecido: {command}").into()),
    }
    Ok(())
}

fn print_group(title: &str, paths: &[String]) {
    if paths.is_empty() { return; }
    println!("{title}:");
    for path in paths {
        println!("  {path}");
    }
}

use std::fmt::Write;

pub fn sha1(input: &[u8]) -> String {
    let mut message = input.to_vec();
    let bit_len = (message.len() as u64) * 8;
    message.push(0x80);
    while message.len() % 64 != 56 {
        message.push(0);
    }
    message.extend_from_slice(&bit_len.to_be_bytes());

    let mut h0 = 0x6745_2301_u32;
    let mut h1 = 0xEFCD_AB89_u32;
    let mut h2 = 0x98BA_DCFE_u32;
    let mut h3 = 0x1032_5476_u32;
    let mut h4 = 0xC3D2_E1F0_u32;

    for chunk in message.chunks_exact(64) {
        let mut words = [0_u32; 80];
        for (index, word) in words.iter_mut().take(16).enumerate() {
            let start = index * 4;
            *word = u32::from_be_bytes(chunk[start..start + 4].try_into().unwrap());
        }
        for index in 16..80 {
            words[index] = (words[index - 3]
                ^ words[index - 8]
                ^ words[index - 14]
                ^ words[index - 16])
                .rotate_left(1);
        }

        let (mut a, mut b, mut c, mut d, mut e) = (h0, h1, h2, h3, h4);
        for (index, word) in words.iter().enumerate() {
            let (function, constant) = match index {
                0..=19 => ((b & c) | ((!b) & d), 0x5A82_7999),
                20..=39 => (b ^ c ^ d, 0x6ED9_EBA1),
                40..=59 => ((b & c) | (b & d) | (c & d), 0x8F1B_BCDC),
                _ => (b ^ c ^ d, 0xCA62_C1D6),
            };
            let next = a
                .rotate_left(5)
                .wrapping_add(function)
                .wrapping_add(e)
                .wrapping_add(constant)
                .wrapping_add(*word);
            e = d;
            d = c;
            c = b.rotate_left(30);
            b = a;
            a = next;
        }

        h0 = h0.wrapping_add(a);
        h1 = h1.wrapping_add(b);
        h2 = h2.wrapping_add(c);
        h3 = h3.wrapping_add(d);
        h4 = h4.wrapping_add(e);
    }

    let mut output = String::with_capacity(40);
    for value in [h0, h1, h2, h3, h4] {
        write!(&mut output, "{value:08x}").unwrap();
    }
    output
}

#[cfg(test)]
mod tests {
    use super::sha1;

    #[test]
    fn matches_known_sha1_vectors() {
        assert_eq!(sha1(b""), "da39a3ee5e6b4b0d3255bfef95601890afd80709");
        assert_eq!(sha1(b"abc"), "a9993e364706816aba3e25717850c26c9cd0d89d");
    }
}

use crate::{hash::sha1, Result};
use std::{fs, path::{Path, PathBuf}};

#[derive(Debug, Clone)]
pub struct Object {
    pub kind: String,
    pub data: Vec<u8>,
}

#[derive(Debug, Clone)]
pub struct ObjectStore {
    root: PathBuf,
}

impl ObjectStore {
    pub fn new(rastro_dir: &Path) -> Self {
        Self { root: rastro_dir.join("objects") }
    }

    pub fn hash_object(kind: &str, data: &[u8]) -> String {
        let mut encoded = format!("{kind} {}\0", data.len()).into_bytes();
        encoded.extend_from_slice(data);
        sha1(&encoded)
    }

    pub fn write(&self, kind: &str, data: &[u8]) -> Result<String> {
        let oid = Self::hash_object(kind, data);
        let path = self.path_for(&oid)?;
        if !path.exists() {
            if let Some(parent) = path.parent() {
                fs::create_dir_all(parent)?;
            }
            let mut encoded = format!("{kind} {}\0", data.len()).into_bytes();
            encoded.extend_from_slice(data);
            fs::write(path, encoded)?;
        }
        Ok(oid)
    }

    pub fn read(&self, oid: &str) -> Result<Object> {
        let encoded = fs::read(self.path_for(oid)?)?;
        let nul = encoded.iter().position(|byte| *byte == 0)
            .ok_or("objeto sem cabeçalho")?;
        let header = std::str::from_utf8(&encoded[..nul])?;
        let (kind, length) = header.split_once(' ').ok_or("cabeçalho inválido")?;
        let expected: usize = length.parse()?;
        let data = encoded[nul + 1..].to_vec();
        if data.len() != expected {
            return Err("tamanho do objeto não confere".into());
        }
        if Self::hash_object(kind, &data) != oid {
            return Err("hash do objeto não confere".into());
        }
        Ok(Object { kind: kind.to_string(), data })
    }

    pub fn resolve_prefix(&self, prefix: &str) -> Result<String> {
        if prefix.len() >= 40 {
            return Ok(prefix.to_string());
        }
        if prefix.len() < 2 {
            return Err("use pelo menos dois caracteres do hash".into());
        }
        let directory = self.root.join(&prefix[..2]);
        let suffix = &prefix[2..];
        let mut matches = Vec::new();
        if directory.exists() {
            for entry in fs::read_dir(directory)? {
                let name = entry?.file_name().to_string_lossy().to_string();
                if name.starts_with(suffix) {
                    matches.push(format!("{}{}", &prefix[..2], name));
                }
            }
        }
        match matches.as_slice() {
            [oid] => Ok(oid.clone()),
            [] => Err("objeto não encontrado".into()),
            _ => Err("prefixo de hash ambíguo".into()),
        }
    }

    fn path_for(&self, oid: &str) -> Result<PathBuf> {
        if oid.len() != 40 || !oid.bytes().all(|byte| byte.is_ascii_hexdigit()) {
            return Err("hash inválido".into());
        }
        Ok(self.root.join(&oid[..2]).join(&oid[2..]))
    }
}

use crate::{object_store::ObjectStore, Result};
use std::path::Path;

pub fn store_file(store: &ObjectStore, path: &Path) -> Result<String> {
    store.write("blob", &std::fs::read(path)?)
}

pub fn read(store: &ObjectStore, oid: &str) -> Result<Vec<u8>> {
    let object = store.read(oid)?;
    if object.kind != "blob" {
        return Err(format!("esperava blob, encontrei {}", object.kind).into());
    }
    Ok(object.data)
}

use crate::Result;
use std::{collections::BTreeMap, fs, path::Path};

pub type Index = BTreeMap<String, String>;

pub fn load(rastro_dir: &Path) -> Result<Index> {
    let path = rastro_dir.join("index");
    if !path.exists() {
        return Ok(Index::new());
    }
    let text = fs::read_to_string(path)?;
    let mut index = Index::new();
    for line in text.lines() {
        let (oid, path) = line.split_once('\t').ok_or("linha inválida no index")?;
        index.insert(path.to_string(), oid.to_string());
    }
    Ok(index)
}

pub fn save(rastro_dir: &Path, index: &Index) -> Result<()> {
    let mut text = String::new();
    for (path, oid) in index {
        text.push_str(oid);
        text.push('\t');
        text.push_str(path);
        text.push('\n');
    }
    fs::write(rastro_dir.join("index"), text)?;
    Ok(())
}

use crate::{index::Index, object_store::ObjectStore, Result};
use std::collections::{BTreeMap, BTreeSet};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TreeEntry {
    pub kind: String,
    pub oid: String,
    pub name: String,
}

pub fn write_from_index(store: &ObjectStore, index: &Index) -> Result<String> {
    write_level(store, index, "")
}

fn write_level(store: &ObjectStore, index: &Index, prefix: &str) -> Result<String> {
    let mut files = BTreeMap::new();
    let mut directories = BTreeSet::new();

    for (path, oid) in index {
        let Some(relative) = path.strip_prefix(prefix) else { continue };
        if let Some((directory, _)) = relative.split_once('/') {
            directories.insert(directory.to_string());
        } else if !relative.is_empty() {
            files.insert(relative.to_string(), oid.to_string());
        }
    }

    let mut entries = Vec::new();
    for (name, oid) in files {
        entries.push(TreeEntry { kind: "blob".into(), oid, name });
    }
    for name in directories {
        let child_prefix = format!("{prefix}{name}/");
        let oid = write_level(store, index, &child_prefix)?;
        entries.push(TreeEntry { kind: "tree".into(), oid, name });
    }
    entries.sort_by(|a, b| a.name.cmp(&b.name));
    store.write("tree", &encode(&entries))
}

pub fn read(store: &ObjectStore, oid: &str) -> Result<Vec<TreeEntry>> {
    let object = store.read(oid)?;
    if object.kind != "tree" {
        return Err(format!("esperava tree, encontrei {}", object.kind).into());
    }
    decode(&object.data)
}

pub fn flatten(store: &ObjectStore, tree_oid: &str) -> Result<Index> {
    let mut output = Index::new();
    flatten_level(store, tree_oid, "", &mut output)?;
    Ok(output)
}

fn flatten_level(store: &ObjectStore, oid: &str, prefix: &str, output: &mut Index) -> Result<()> {
    for entry in read(store, oid)? {
        let path = if prefix.is_empty() {
            entry.name.clone()
        } else {
            format!("{prefix}/{}", entry.name)
        };
        match entry.kind.as_str() {
            "blob" => { output.insert(path, entry.oid); }
            "tree" => flatten_level(store, &entry.oid, &path, output)?,
            other => return Err(format!("tipo {other} não permitido em tree").into()),
        }
    }
    Ok(())
}

fn encode(entries: &[TreeEntry]) -> Vec<u8> {
    let mut text = String::new();
    for entry in entries {
        text.push_str(&entry.kind);
        text.push(' ');
        text.push_str(&entry.oid);
        text.push('\t');
        text.push_str(&entry.name);
        text.push('\n');
    }
    text.into_bytes()
}

fn decode(data: &[u8]) -> Result<Vec<TreeEntry>> {
    let text = std::str::from_utf8(data)?;
    let mut entries = Vec::new();
    for line in text.lines() {
        let (left, name) = line.split_once('\t').ok_or("entrada de tree inválida")?;
        let (kind, oid) = left.split_once(' ').ok_or("entrada de tree inválida")?;
        entries.push(TreeEntry { kind: kind.into(), oid: oid.into(), name: name.into() });
    }
    Ok(entries)
}

use crate::{object_store::ObjectStore, Result};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Commit {
    pub tree: String,
    pub parents: Vec<String>,
    pub author: String,
    pub timestamp: u64,
    pub message: String,
}

impl Commit {
    pub fn write(&self, store: &ObjectStore) -> Result<String> {
        let mut text = format!("tree {}\n", self.tree);
        for parent in &self.parents {
            text.push_str(&format!("parent {parent}\n"));
        }
        text.push_str(&format!("author {}\n", self.author));
        text.push_str(&format!("timestamp {}\n\n", self.timestamp));
        text.push_str(self.message.trim());
        text.push('\n');
        store.write("commit", text.as_bytes())
    }

    pub fn read(store: &ObjectStore, oid: &str) -> Result<Self> {
        let object = store.read(oid)?;
        if object.kind != "commit" {
            return Err(format!("esperava commit, encontrei {}", object.kind).into());
        }
        let text = std::str::from_utf8(&object.data)?;
        let (headers, message) = text.split_once("\n\n").ok_or("commit inválido")?;
        let mut tree = None;
        let mut parents = Vec::new();
        let mut author = None;
        let mut timestamp = None;
        for line in headers.lines() {
            let (name, value) = line.split_once(' ').ok_or("cabeçalho de commit inválido")?;
            match name {
                "tree" => tree = Some(value.to_string()),
                "parent" => parents.push(value.to_string()),
                "author" => author = Some(value.to_string()),
                "timestamp" => timestamp = Some(value.parse()?),
                _ => {}
            }
        }
        Ok(Self {
            tree: tree.ok_or("commit sem tree")?,
            parents,
            author: author.ok_or("commit sem autor")?,
            timestamp: timestamp.ok_or("commit sem data")?,
            message: message.trim_end().to_string(),
        })
    }
}

use crate::Result;
use std::{fs, path::Path};

#[derive(Debug, Clone)]
pub enum Head {
    Symbolic(String),
    Detached(String),
}

pub fn read(rastro_dir: &Path) -> Result<Head> {
    let value = fs::read_to_string(rastro_dir.join("HEAD"))?;
    let value = value.trim();
    if let Some(reference) = value.strip_prefix("ref: ") {
        Ok(Head::Symbolic(reference.to_string()))
    } else {
        Ok(Head::Detached(value.to_string()))
    }
}

pub fn write(rastro_dir: &Path, head: &Head) -> Result<()> {
    let value = match head {
        Head::Symbolic(reference) => format!("ref: {reference}\n"),
        Head::Detached(oid) => format!("{oid}\n"),
    };
    fs::write(rastro_dir.join("HEAD"), value)?;
    Ok(())
}

use crate::{head::{self, Head}, Result};
use std::{fs, path::Path};

pub fn validate_branch_name(name: &str) -> Result<()> {
    if name.is_empty()
        || name.starts_with('.')
        || name.ends_with('.')
        || name.contains("..")
        || name.chars().any(|c| matches!(c, '/' | '\\' | ' ' | '\t' | '\n'))
    {
        return Err("nome de branch inválido".into());
    }
    Ok(())
}

pub fn read_ref(rastro_dir: &Path, name: &str) -> Result<Option<String>> {
    let path = rastro_dir.join(name);
    if !path.exists() {
        return Ok(None);
    }
    Ok(Some(fs::read_to_string(path)?.trim().to_string()))
}

pub fn resolve_head(rastro_dir: &Path) -> Result<Option<String>> {
    match head::read(rastro_dir)? {
        Head::Symbolic(reference) => read_ref(rastro_dir, &reference),
        Head::Detached(oid) if oid.is_empty() => Ok(None),
        Head::Detached(oid) => Ok(Some(oid)),
    }
}

pub fn update_head(rastro_dir: &Path, oid: &str) -> Result<()> {
    match head::read(rastro_dir)? {
        Head::Symbolic(reference) => {
            let path = rastro_dir.join(reference);
            if let Some(parent) = path.parent() {
                fs::create_dir_all(parent)?;
            }
            fs::write(path, format!("{oid}\n"))?;
        }
        Head::Detached(_) => head::write(rastro_dir, &Head::Detached(oid.to_string()))?,
    }
    Ok(())
}

pub fn create_branch(rastro_dir: &Path, name: &str, oid: &str) -> Result<()> {
    validate_branch_name(name)?;
    let path = rastro_dir.join("refs").join("heads").join(name);
    if path.exists() {
        return Err(format!("a branch {name} já existe").into());
    }
    fs::write(path, format!("{oid}\n"))?;
    Ok(())
}

pub fn current_branch(rastro_dir: &Path) -> Result<Option<String>> {
    match head::read(rastro_dir)? {
        Head::Symbolic(reference) => Ok(reference
            .strip_prefix("refs/heads/")
            .map(ToString::to_string)),
        Head::Detached(_) => Ok(None),
    }
}

pub fn list_branches(rastro_dir: &Path) -> Result<Vec<String>> {
    let directory = rastro_dir.join("refs").join("heads");
    let mut branches = Vec::new();
    for entry in fs::read_dir(directory)? {
        let entry = entry?;
        if entry.file_type()?.is_file() {
            branches.push(entry.file_name().to_string_lossy().to_string());
        }
    }
    branches.sort();
    Ok(branches)
}

pub fn delete_branch(rastro_dir: &Path, name: &str) -> Result<()> {
    validate_branch_name(name)?;
    let path = rastro_dir.join("refs").join("heads").join(name);
    if !path.exists() {
        return Err(format!("a branch {name} não existe").into());
    }
    fs::remove_file(path)?;
    Ok(())
}

use crate::{commit::Commit, object_store::ObjectStore, Result};

pub fn collect(store: &ObjectStore, start: Option<String>) -> Result<Vec<(String, Commit)>> {
    let mut commits = Vec::new();
    let mut current = start;
    while let Some(oid) = current {
        let commit = Commit::read(store, &oid)?;
        current = commit.parents.first().cloned();
        commits.push((oid, commit));
    }
    Ok(commits)
}

pub fn format_timestamp(seconds: u64) -> String {
    format!("{seconds} segundos desde 1970-01-01 UTC")
}

use crate::{commit::Commit, index::Index, object_store::ObjectStore, Result};
use std::collections::{BTreeSet, VecDeque};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MergeStrategy {
    Manual,
    Ours,
    Theirs,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Conflict {
    pub path: String,
    pub ours: Option<String>,
    pub theirs: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MergePlan {
    pub index: Index,
    pub conflicts: Vec<Conflict>,
}

pub fn is_ancestor(store: &ObjectStore, ancestor: &str, descendant: &str) -> Result<bool> {
    Ok(ancestors(store, descendant)?.contains(ancestor))
}

pub fn merge_base(store: &ObjectStore, left: &str, right: &str) -> Result<Option<String>> {
    let left_ancestors = ancestors(store, left)?;
    let mut queue = VecDeque::from([right.to_string()]);
    let mut visited = BTreeSet::new();

    while let Some(oid) = queue.pop_front() {
        if !visited.insert(oid.clone()) {
            continue;
        }
        if left_ancestors.contains(&oid) {
            return Ok(Some(oid));
        }
        queue.extend(Commit::read(store, &oid)?.parents);
    }
    Ok(None)
}

pub fn three_way(
    base: &Index,
    ours: &Index,
    theirs: &Index,
    strategy: MergeStrategy,
) -> MergePlan {
    let paths: BTreeSet<_> = base.keys()
        .chain(ours.keys())
        .chain(theirs.keys())
        .cloned()
        .collect();
    let mut merged = Index::new();
    let mut conflicts = Vec::new();

    for path in paths {
        let base_value = base.get(&path);
        let our_value = ours.get(&path);
        let their_value = theirs.get(&path);

        let chosen = if our_value == their_value {
            our_value
        } else if our_value == base_value {
            their_value
        } else if their_value == base_value {
            our_value
        } else {
            match strategy {
                MergeStrategy::Ours => our_value,
                MergeStrategy::Theirs => their_value,
                MergeStrategy::Manual => {
                    conflicts.push(Conflict {
                        path: path.clone(),
                        ours: our_value.cloned(),
                        theirs: their_value.cloned(),
                    });
                    our_value
                }
            }
        };

        if let Some(oid) = chosen {
            merged.insert(path, oid.clone());
        }
    }

    MergePlan { index: merged, conflicts }
}

fn ancestors(store: &ObjectStore, start: &str) -> Result<BTreeSet<String>> {
    let mut found = BTreeSet::new();
    let mut queue = VecDeque::from([start.to_string()]);
    while let Some(oid) = queue.pop_front() {
        if found.insert(oid.clone()) {
            queue.extend(Commit::read(store, &oid)?.parents);
        }
    }
    Ok(found)
}

use crate::{blob, index::{self, Index}, object_store::ObjectStore, Result};
use std::{fs, path::Path};

pub fn restore(root: &Path, rastro_dir: &Path, store: &ObjectStore, target: &Index) -> Result<()> {
    let current = index::load(rastro_dir)?;
    for path in current.keys() {
        if !target.contains_key(path) {
            let full = root.join(path);
            if full.is_file() {
                fs::remove_file(full)?;
            }
        }
    }

    for (path, oid) in target {
        let full = root.join(path);
        if let Some(parent) = full.parent() {
            fs::create_dir_all(parent)?;
        }
        fs::write(full, blob::read(store, oid)?)?;
    }
    remove_empty_directories(root)?;
    index::save(rastro_dir, target)?;
    Ok(())
}

fn remove_empty_directories(root: &Path) -> Result<()> {
    fn visit(path: &Path) -> std::io::Result<bool> {
        let mut empty = true;
        for entry in std::fs::read_dir(path)? {
            let entry = entry?;
            let child = entry.path();
            if entry.file_name().to_string_lossy() == ".rastro" {
                empty = false;
            } else if child.is_dir() {
                if visit(&child)? {
                    std::fs::remove_dir(&child)?;
                } else {
                    empty = false;
                }
            } else {
                empty = false;
            }
        }
        Ok(empty)
    }
    let _ = visit(root)?;
    Ok(())
}

use crate::{
    blob, checkout, commit::Commit, head::{self, Head}, index::{self, Index},
    merge, object_store::ObjectStore, refs, tree, Result,
};
use std::{
    collections::BTreeSet,
    env, fs,
    path::{Path, PathBuf},
    time::{SystemTime, UNIX_EPOCH},
};

#[derive(Debug, Clone)]
pub struct Repository {
    pub root: PathBuf,
    pub rastro_dir: PathBuf,
    pub store: ObjectStore,
}

#[derive(Debug, Default)]
pub struct Status {
    pub staged: Vec<String>,
    pub modified: Vec<String>,
    pub untracked: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MergeOutcome {
    AlreadyUpToDate,
    FastForward(String),
    MergeCommit(String),
    Conflicts(Vec<String>),
}

impl Repository {
    pub fn init(path: &Path) -> Result<Self> {
        fs::create_dir_all(path)?;
        let root = path.canonicalize()?;
        let rastro_dir = root.join(".rastro");
        if rastro_dir.exists() {
            return Err("este diretório já contém um repositório do Rastro".into());
        }
        fs::create_dir_all(rastro_dir.join("objects"))?;
        fs::create_dir_all(rastro_dir.join("refs").join("heads"))?;
        fs::write(rastro_dir.join("HEAD"), "ref: refs/heads/main\n")?;
        fs::write(rastro_dir.join("config"), "[core]\nrepositoryformatversion = 0\n")?;
        index::save(&rastro_dir, &Index::new())?;
        Ok(Self { root, store: ObjectStore::new(&rastro_dir), rastro_dir })
    }

    pub fn discover(start: &Path) -> Result<Self> {
        let mut current = start.canonicalize()?;
        loop {
            let rastro_dir = current.join(".rastro");
            if rastro_dir.is_dir() {
                return Ok(Self {
                    root: current,
                    store: ObjectStore::new(&rastro_dir),
                    rastro_dir,
                });
            }
            if !current.pop() {
                return Err("não estamos dentro de um repositório do Rastro".into());
            }
        }
    }

    pub fn add(&self, paths: &[PathBuf]) -> Result<()> {
        let mut index = index::load(&self.rastro_dir)?;
        for path in paths {
            let absolute = if path.is_absolute() { path.clone() } else { self.root.join(path) };
            self.add_path(&absolute, &mut index)?;
        }
        index::save(&self.rastro_dir, &index)
    }

    pub fn commit(&self, message: &str) -> Result<String> {
        if message.trim().is_empty() {
            return Err("a mensagem do commit não pode ficar vazia".into());
        }
        let index = index::load(&self.rastro_dir)?;
        if index.is_empty() {
            return Err("o index está vazio; use rastro add".into());
        }
        let tree = tree::write_from_index(&self.store, &index)?;
        let merge_parent = self.read_merge_head()?;
        if let Some(parent) = refs::resolve_head(&self.rastro_dir)? {
            let previous = Commit::read(&self.store, &parent)?;
            if previous.tree == tree && merge_parent.is_none() {
                return Err("nenhuma alteração adicionada ao commit".into());
            }
        }
        let author = env::var("RASTRO_AUTHOR")
            .or_else(|_| env::var("USER"))
            .unwrap_or_else(|_| "Pessoa autora".into());
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
        let mut parents: Vec<String> =
            refs::resolve_head(&self.rastro_dir)?.into_iter().collect();
        if let Some(parent) = merge_parent {
            parents.push(parent);
        }
        let commit = Commit {
            tree,
            parents,
            author,
            timestamp,
            message: message.trim().to_string(),
        };
        let oid = commit.write(&self.store)?;
        refs::update_head(&self.rastro_dir, &oid)?;
        self.clear_merge_state()?;
        Ok(oid)
    }

    pub fn status(&self) -> Result<Status> {
        let index = index::load(&self.rastro_dir)?;
        let head_snapshot = self.head_snapshot()?;
        let mut status = Status::default();

        let all_paths: BTreeSet<_> = index.keys().chain(head_snapshot.keys()).cloned().collect();
        for path in all_paths {
            if index.get(&path) != head_snapshot.get(&path) {
                status.staged.push(path);
            }
        }
        for (path, oid) in &index {
            let full = self.root.join(path);
            if !full.exists() || ObjectStore::hash_object("blob", &fs::read(full)?) != oid.as_str() {
                status.modified.push(path.clone());
            }
        }
        let mut working = Vec::new();
        collect_files(&self.root, &self.root, &mut working)?;
        for path in working {
            if !index.contains_key(&path) {
                status.untracked.push(path);
            }
        }
        Ok(status)
    }

    pub fn checkout(&self, target: &str) -> Result<String> {
        let status = self.status()?;
        if !status.modified.is_empty() || !status.staged.is_empty() {
            return Err("checkout cancelado: existem alterações locais ou preparadas".into());
        }
        let branch_ref = format!("refs/heads/{target}");
        let (oid, new_head) = if let Some(oid) = refs::read_ref(&self.rastro_dir, &branch_ref)? {
            (oid, Head::Symbolic(branch_ref))
        } else {
            let oid = self.store.resolve_prefix(target)?;
            (oid.clone(), Head::Detached(oid))
        };
        let commit = Commit::read(&self.store, &oid)?;
        let snapshot = tree::flatten(&self.store, &commit.tree)?;
        if let Some(path) = status.untracked.iter().find(|path| snapshot.contains_key(*path)) {
            return Err(format!("checkout sobrescreveria o arquivo não rastreado {path}").into());
        }
        checkout::restore(&self.root, &self.rastro_dir, &self.store, &snapshot)?;
        head::write(&self.rastro_dir, &new_head)?;
        Ok(oid)
    }

    pub fn create_branch(&self, name: &str) -> Result<()> {
        let oid = refs::resolve_head(&self.rastro_dir)?.ok_or("ainda não existe commit")?;
        refs::create_branch(&self.rastro_dir, name, &oid)
    }

    pub fn list_branches(&self) -> Result<Vec<(String, bool)>> {
        let current = refs::current_branch(&self.rastro_dir)?;
        Ok(refs::list_branches(&self.rastro_dir)?
            .into_iter()
            .map(|name| {
                let selected = current.as_deref() == Some(name.as_str());
                (name, selected)
            })
            .collect())
    }

    pub fn delete_branch(&self, name: &str, force: bool) -> Result<()> {
        if refs::current_branch(&self.rastro_dir)?.as_deref() == Some(name) {
            return Err("não é possível excluir a branch atualmente selecionada".into());
        }
        let reference = format!("refs/heads/{name}");
        let tip = refs::read_ref(&self.rastro_dir, &reference)?
            .ok_or_else(|| format!("a branch {name} não existe"))?;
        let current = refs::resolve_head(&self.rastro_dir)?
            .ok_or("a branch atual ainda não possui commit")?;
        if !force && !merge::is_ancestor(&self.store, &tip, &current)? {
            return Err(format!(
                "a branch {name} possui commits não integrados; use -D para forçar"
            ).into());
        }
        refs::delete_branch(&self.rastro_dir, name)
    }

    pub fn merge(&self, branch: &str, strategy: merge::MergeStrategy) -> Result<MergeOutcome> {
        if self.read_merge_head()?.is_some() {
            return Err("já existe um merge em andamento; conclua o commit ou use merge --abort".into());
        }
        self.ensure_clean("merge")?;
        let current_branch = refs::current_branch(&self.rastro_dir)?
            .ok_or("merge exige HEAD apontando para uma branch")?;
        if current_branch == branch {
            return Err("não é possível fazer merge de uma branch nela mesma".into());
        }

        let current = refs::resolve_head(&self.rastro_dir)?
            .ok_or("a branch atual ainda não possui commit")?;
        let target_ref = format!("refs/heads/{branch}");
        let target = refs::read_ref(&self.rastro_dir, &target_ref)?
            .ok_or_else(|| format!("a branch {branch} não existe"))?;

        if merge::is_ancestor(&self.store, &target, &current)? {
            return Ok(MergeOutcome::AlreadyUpToDate);
        }
        if merge::is_ancestor(&self.store, &current, &target)? {
            let snapshot = self.snapshot_at(&target)?;
            self.protect_untracked(&snapshot)?;
            checkout::restore(&self.root, &self.rastro_dir, &self.store, &snapshot)?;
            refs::update_head(&self.rastro_dir, &target)?;
            return Ok(MergeOutcome::FastForward(target));
        }

        let base_oid = merge::merge_base(&self.store, &current, &target)?
            .ok_or("as branches não possuem ancestral comum")?;
        let base = self.snapshot_at(&base_oid)?;
        let ours = self.snapshot_at(&current)?;
        let theirs = self.snapshot_at(&target)?;
        let mut plan = merge::three_way(&base, &ours, &theirs, strategy);
        if strategy == merge::MergeStrategy::Manual && !plan.conflicts.is_empty() {
            for conflict in &plan.conflicts {
                let ours = self.conflict_text(conflict.ours.as_deref(), "arquivo ausente")?;
                let theirs = self.conflict_text(conflict.theirs.as_deref(), "arquivo ausente")?;
                let marked = format!(
                    "<<<<<<< nossa branch ({current_branch})\n{ours}=======\n{theirs}>>>>>>> branch recebida ({branch})\n"
                );
                let oid = self.store.write("blob", marked.as_bytes())?;
                plan.index.insert(conflict.path.clone(), oid);
            }
            self.protect_untracked(&plan.index)?;
            checkout::restore(&self.root, &self.rastro_dir, &self.store, &plan.index)?;
            fs::write(self.rastro_dir.join("MERGE_HEAD"), format!("{target}\n"))?;
            fs::write(
                self.rastro_dir.join("MERGE_MSG"),
                format!("merge da branch {branch}; resolva os conflitos, use add e commit\n"),
            )?;
            return Ok(MergeOutcome::Conflicts(
                plan.conflicts.into_iter().map(|conflict| conflict.path).collect(),
            ));
        }
        self.protect_untracked(&plan.index)?;
        checkout::restore(&self.root, &self.rastro_dir, &self.store, &plan.index)?;

        let tree = tree::write_from_index(&self.store, &plan.index)?;
        let author = env::var("RASTRO_AUTHOR")
            .or_else(|_| env::var("USER"))
            .unwrap_or_else(|_| "Pessoa autora".into());
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs();
        let commit = Commit {
            tree,
            parents: vec![current, target],
            author,
            timestamp,
            message: format!("merge da branch {branch}"),
        };
        let oid = commit.write(&self.store)?;
        refs::update_head(&self.rastro_dir, &oid)?;
        Ok(MergeOutcome::MergeCommit(oid))
    }

    pub fn abort_merge(&self) -> Result<()> {
        if self.read_merge_head()?.is_none() {
            return Err("não existe merge em andamento".into());
        }
        let snapshot = self.head_snapshot()?;
        checkout::restore(&self.root, &self.rastro_dir, &self.store, &snapshot)?;
        self.clear_merge_state()
    }

    pub fn head_snapshot(&self) -> Result<Index> {
        let Some(oid) = refs::resolve_head(&self.rastro_dir)? else {
            return Ok(Index::new());
        };
        let commit = Commit::read(&self.store, &oid)?;
        tree::flatten(&self.store, &commit.tree)
    }

    fn snapshot_at(&self, oid: &str) -> Result<Index> {
        let commit = Commit::read(&self.store, oid)?;
        tree::flatten(&self.store, &commit.tree)
    }

    fn ensure_clean(&self, operation: &str) -> Result<()> {
        let status = self.status()?;
        if status.modified.is_empty() && status.staged.is_empty() {
            Ok(())
        } else {
            Err(format!(
                "{operation} cancelado: existem alterações locais ou preparadas"
            ).into())
        }
    }

    fn protect_untracked(&self, snapshot: &Index) -> Result<()> {
        let status = self.status()?;
        if let Some(path) = status.untracked.iter().find(|path| snapshot.contains_key(*path)) {
            return Err(format!("a operação sobrescreveria o arquivo não rastreado {path}").into());
        }
        Ok(())
    }

    fn read_merge_head(&self) -> Result<Option<String>> {
        let path = self.rastro_dir.join("MERGE_HEAD");
        if !path.exists() {
            return Ok(None);
        }
        Ok(Some(fs::read_to_string(path)?.trim().to_string()))
    }

    fn clear_merge_state(&self) -> Result<()> {
        for name in ["MERGE_HEAD", "MERGE_MSG"] {
            let path = self.rastro_dir.join(name);
            if path.exists() {
                fs::remove_file(path)?;
            }
        }
        Ok(())
    }

    fn conflict_text(&self, oid: Option<&str>, missing: &str) -> Result<String> {
        let bytes = match oid {
            Some(oid) => blob::read(&self.store, oid)?,
            None => return Ok(format!("[{missing}]\n")),
        };
        let mut text = String::from_utf8(bytes)
            .map_err(|_| "conflito em arquivo binário; repita com --ours ou --theirs")?;
        if !text.ends_with('\n') {
            text.push('\n');
        }
        Ok(text)
    }

    fn add_path(&self, absolute: &Path, index: &mut Index) -> Result<()> {
        if absolute == self.rastro_dir || absolute.starts_with(&self.rastro_dir) {
            return Ok(());
        }
        if absolute.is_dir() {
            for entry in fs::read_dir(absolute)? {
                self.add_path(&entry?.path(), index)?;
            }
        } else if absolute.is_file() {
            let relative = absolute.strip_prefix(&self.root)?
                .to_string_lossy().replace('\\', "/");
            if relative.contains('\n') || relative.contains('\t') {
                return Err("o Rastro não aceita tab ou quebra de linha no caminho".into());
            }
            let oid = blob::store_file(&self.store, absolute)?;
            index.insert(relative, oid);
        } else {
            return Err(format!("caminho não encontrado: {}", absolute.display()).into());
        }
        Ok(())
    }
}

fn collect_files(root: &Path, current: &Path, output: &mut Vec<String>) -> Result<()> {
    for entry in fs::read_dir(current)? {
        let path = entry?.path();
        if path == root.join(".rastro") {
            continue;
        }
        if path.is_dir() {
            collect_files(root, &path, output)?;
        } else if path.is_file() {
            output.push(path.strip_prefix(root)?.to_string_lossy().replace('\\', "/"));
        }
    }
    output.sort();
    Ok(())
}

use rastro::{
    commit::Commit, log, merge::MergeStrategy, refs,
    repository::{MergeOutcome, Repository},
};
use std::{fs, path::PathBuf, time::{SystemTime, UNIX_EPOCH}};

fn temporary_directory() -> PathBuf {
    let unique = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
    std::env::temp_dir().join(format!("rastro-test-{}-{unique}", std::process::id()))
}

#[test]
fn commit_log_status_and_checkout_complete_a_round_trip() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();

    fs::write(root.join("README.md"), "primeira versão\n").unwrap();
    fs::create_dir(root.join("src")).unwrap();
    fs::write(root.join("src/main.rs"), "fn main() {}\n").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    let first = repository.commit("primeira versão").unwrap();

    fs::write(root.join("README.md"), "segunda versão\n").unwrap();
    let before_add = repository.status().unwrap();
    assert_eq!(before_add.modified, vec!["README.md"]);

    repository.add(&[PathBuf::from("README.md")]).unwrap();
    let second = repository.commit("atualiza README").unwrap();
    assert_ne!(first, second);

    let history = log::collect(&repository.store, refs::resolve_head(&repository.rastro_dir).unwrap()).unwrap();
    assert_eq!(history.len(), 2);
    assert_eq!(history[0].1.message, "atualiza README");
    assert_eq!(history[1].1.message, "primeira versão");

    repository.checkout(&first[..8]).unwrap();
    assert_eq!(fs::read_to_string(root.join("README.md")).unwrap(), "primeira versão\n");
    assert!(matches!(rastro::head::read(&repository.rastro_dir).unwrap(), rastro::head::Head::Detached(_)));

    fs::remove_dir_all(root).unwrap();
}

#[test]
fn equal_file_contents_share_the_same_blob() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();
    fs::write(root.join("a.txt"), "igual").unwrap();
    fs::write(root.join("b.txt"), "igual").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();

    let index = rastro::index::load(&repository.rastro_dir).unwrap();
    assert_eq!(index["a.txt"], index["b.txt"]);
    fs::remove_dir_all(root).unwrap();
}

#[test]
fn commit_points_to_a_tree_and_to_its_parent() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();
    fs::write(root.join("nota.txt"), "um").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    let first = repository.commit("um").unwrap();

    fs::write(root.join("nota.txt"), "dois").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    let second = repository.commit("dois").unwrap();
    let parsed = Commit::read(&repository.store, &second).unwrap();

    assert_eq!(parsed.parents, vec![first]);
    assert_eq!(repository.store.read(&parsed.tree).unwrap().kind, "tree");
    fs::remove_dir_all(root).unwrap();
}

#[test]
fn branch_checkout_merge_and_delete_complete_the_workflow() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();
    fs::write(root.join("base.txt"), "base\n").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    repository.commit("base").unwrap();

    repository.create_branch("ideia").unwrap();
    repository.checkout("ideia").unwrap();
    fs::write(root.join("ideia.txt"), "feito na ideia\n").unwrap();
    repository.add(&[PathBuf::from("ideia.txt")]).unwrap();
    let idea_tip = repository.commit("trabalho paralelo").unwrap();

    repository.checkout("main").unwrap();
    fs::write(root.join("main.txt"), "feito na main\n").unwrap();
    repository.add(&[PathBuf::from("main.txt")]).unwrap();
    let main_tip = repository.commit("trabalho principal").unwrap();

    let outcome = repository.merge("ideia", MergeStrategy::Manual).unwrap();
    let MergeOutcome::MergeCommit(merge_oid) = outcome else {
        panic!("esperava um commit de merge");
    };
    let merge_commit = Commit::read(&repository.store, &merge_oid).unwrap();
    assert_eq!(merge_commit.parents, vec![main_tip, idea_tip]);
    assert_eq!(fs::read_to_string(root.join("ideia.txt")).unwrap(), "feito na ideia\n");
    assert_eq!(fs::read_to_string(root.join("main.txt")).unwrap(), "feito na main\n");

    repository.delete_branch("ideia", false).unwrap();
    assert_eq!(repository.list_branches().unwrap(), vec![("main".into(), true)]);
    fs::remove_dir_all(root).unwrap();
}

#[test]
fn merge_uses_fast_forward_when_current_branch_has_not_diverged() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();
    fs::write(root.join("nota.txt"), "base\n").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    repository.commit("base").unwrap();

    repository.create_branch("ideia").unwrap();
    repository.checkout("ideia").unwrap();
    fs::write(root.join("nota.txt"), "ideia pronta\n").unwrap();
    repository.add(&[PathBuf::from("nota.txt")]).unwrap();
    let target = repository.commit("termina ideia").unwrap();
    repository.checkout("main").unwrap();

    assert_eq!(
        repository.merge("ideia", MergeStrategy::Manual).unwrap(),
        MergeOutcome::FastForward(target)
    );
    assert_eq!(fs::read_to_string(root.join("nota.txt")).unwrap(), "ideia pronta\n");
    fs::remove_dir_all(root).unwrap();
}

#[test]
fn manual_conflict_writes_markers_and_commit_keeps_two_parents() {
    let root = temporary_directory();
    let repository = Repository::init(&root).unwrap();
    fs::write(root.join("nota.txt"), "texto original\n").unwrap();
    repository.add(&[PathBuf::from(".")]).unwrap();
    repository.commit("base").unwrap();

    repository.create_branch("ideia").unwrap();
    repository.checkout("ideia").unwrap();
    fs::write(root.join("nota.txt"), "texto da ideia\n").unwrap();
    repository.add(&[PathBuf::from("nota.txt")]).unwrap();
    let idea_tip = repository.commit("altera na ideia").unwrap();

    repository.checkout("main").unwrap();
    fs::write(root.join("nota.txt"), "texto da main\n").unwrap();
    repository.add(&[PathBuf::from("nota.txt")]).unwrap();
    let main_tip = repository.commit("altera na main").unwrap();

    assert_eq!(
        repository.merge("ideia", MergeStrategy::Manual).unwrap(),
        MergeOutcome::Conflicts(vec!["nota.txt".into()])
    );
    let marked = fs::read_to_string(root.join("nota.txt")).unwrap();
    assert!(marked.contains("<<<<<<< nossa branch (main)"));
    assert!(marked.contains("texto da main"));
    assert!(marked.contains("texto da ideia"));

    fs::write(root.join("nota.txt"), "texto combinado\n").unwrap();
    repository.add(&[PathBuf::from("nota.txt")]).unwrap();
    let merge_oid = repository.commit("resolve conflito").unwrap();
    let merge_commit = Commit::read(&repository.store, &merge_oid).unwrap();
    assert_eq!(merge_commit.parents, vec![main_tip, idea_tip]);
    assert!(!repository.rastro_dir.join("MERGE_HEAD").exists());
    fs::remove_dir_all(root).unwrap();
}

#[test]
fn ours_theirs_and_abort_are_explicit_conflict_strategies() {
    fn divergent_repository() -> (PathBuf, Repository) {
        let root = temporary_directory();
        let repository = Repository::init(&root).unwrap();
        fs::write(root.join("nota.txt"), "base\n").unwrap();
        repository.add(&[PathBuf::from(".")]).unwrap();
        repository.commit("base").unwrap();
        repository.create_branch("ideia").unwrap();
        repository.checkout("ideia").unwrap();
        fs::write(root.join("nota.txt"), "theirs\n").unwrap();
        repository.add(&[PathBuf::from("nota.txt")]).unwrap();
        repository.commit("theirs").unwrap();
        repository.checkout("main").unwrap();
        fs::write(root.join("nota.txt"), "ours\n").unwrap();
        repository.add(&[PathBuf::from("nota.txt")]).unwrap();
        repository.commit("ours").unwrap();
        (root, repository)
    }

    let (ours_root, ours_repository) = divergent_repository();
    ours_repository.merge("ideia", MergeStrategy::Ours).unwrap();
    assert_eq!(fs::read_to_string(ours_root.join("nota.txt")).unwrap(), "ours\n");
    fs::remove_dir_all(ours_root).unwrap();

    let (theirs_root, theirs_repository) = divergent_repository();
    theirs_repository.merge("ideia", MergeStrategy::Theirs).unwrap();
    assert_eq!(fs::read_to_string(theirs_root.join("nota.txt")).unwrap(), "theirs\n");
    fs::remove_dir_all(theirs_root).unwrap();

    let (abort_root, abort_repository) = divergent_repository();
    abort_repository.merge("ideia", MergeStrategy::Manual).unwrap();
    abort_repository.abort_merge().unwrap();
    assert_eq!(fs::read_to_string(abort_root.join("nota.txt")).unwrap(), "ours\n");
    assert!(!abort_repository.rastro_dir.join("MERGE_HEAD").exists());
    fs::remove_dir_all(abort_root).unwrap();
}