void_core/ops/

merge_state.rs

//! Merge state file helpers.
//!
//! This module manages the state files that track an in-progress merge.
//! Files are stored in `.void/` and include:
//! - MERGE_HEAD: hex-encoded CID of commit being merged
//! - MERGE_BASE: hex-encoded CID of merge base (optional)
//! - MERGE_MSG: commit message text
//! - MERGE_CONFLICTS: JSON array of conflicted paths
//! - ORIG_HEAD: hex-encoded CID of HEAD before merge

use std::fs;
use std::path::Path;

use serde::{Deserialize, Serialize};
use void_crypto::CommitCid;

use crate::support::util::atomic_write_str;
use crate::support::Result;

/// State of an in-progress merge.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MergeState {
    /// CID of commit being merged (theirs)
    pub merge_head: CommitCid,
    /// CID of common ancestor (optional)
    pub merge_base: Option<CommitCid>,
    /// HEAD before merge started
    pub orig_head: CommitCid,
    /// Conflicted paths
    pub conflicts: Vec<String>,
    /// Pre-populated commit message
    pub message: String,
}

const MERGE_HEAD: &str = "MERGE_HEAD";
const MERGE_BASE: &str = "MERGE_BASE";
const MERGE_MSG: &str = "MERGE_MSG";
const MERGE_CONFLICTS: &str = "MERGE_CONFLICTS";
const ORIG_HEAD: &str = "ORIG_HEAD";

/// Read the current merge state from the void directory.
///
/// Returns `Ok(None)` if no merge is in progress.
pub fn read_merge_state(void_dir: &Path) -> Result<Option<MergeState>> {
    let merge_head_path = void_dir.join(MERGE_HEAD);

    // If MERGE_HEAD doesn't exist, no merge is in progress
    if !merge_head_path.exists() {
        return Ok(None);
    }

    // Read MERGE_HEAD (required)
    let merge_head_hex = fs::read_to_string(&merge_head_path)?;
    let merge_head = CommitCid::from_bytes(hex::decode(merge_head_hex.trim())
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?);

    // Read ORIG_HEAD (required if MERGE_HEAD exists)
    let orig_head_path = void_dir.join(ORIG_HEAD);
    let orig_head_hex = fs::read_to_string(orig_head_path)?;
    let orig_head = CommitCid::from_bytes(hex::decode(orig_head_hex.trim())
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?);

    // Read MERGE_BASE (optional)
    let merge_base_path = void_dir.join(MERGE_BASE);
    let merge_base = if merge_base_path.exists() {
        let hex_str = fs::read_to_string(&merge_base_path)?;
        Some(CommitCid::from_bytes(
            hex::decode(hex_str.trim())
                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?,
        ))
    } else {
        None
    };

    // Read MERGE_MSG (default to empty string if missing)
    let message_path = void_dir.join(MERGE_MSG);
    let message = if message_path.exists() {
        fs::read_to_string(&message_path)?
    } else {
        String::new()
    };

    // Read MERGE_CONFLICTS (default to empty array if missing)
    let conflicts_path = void_dir.join(MERGE_CONFLICTS);
    let conflicts: Vec<String> = if conflicts_path.exists() {
        let content = fs::read_to_string(&conflicts_path)?;
        serde_json::from_str(&content)
            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?
    } else {
        Vec::new()
    };

    Ok(Some(MergeState {
        merge_head,
        merge_base,
        orig_head,
        conflicts,
        message,
    }))
}

/// Write merge state to the void directory.
///
/// Uses atomic writes to prevent corruption.
pub fn write_merge_state(void_dir: &Path, state: &MergeState) -> Result<()> {
    // Write MERGE_HEAD
    let merge_head_hex = hex::encode(state.merge_head.as_bytes());
    atomic_write_str(void_dir.join(MERGE_HEAD), &merge_head_hex)?;

    // Write ORIG_HEAD
    let orig_head_hex = hex::encode(state.orig_head.as_bytes());
    atomic_write_str(void_dir.join(ORIG_HEAD), &orig_head_hex)?;

    // Write MERGE_BASE (if present)
    if let Some(ref base) = state.merge_base {
        let base_hex = hex::encode(base.as_bytes());
        atomic_write_str(void_dir.join(MERGE_BASE), &base_hex)?;
    }

    // Write MERGE_MSG
    atomic_write_str(void_dir.join(MERGE_MSG), &state.message)?;

    // Write MERGE_CONFLICTS
    let conflicts_json = serde_json::to_string(&state.conflicts)
        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
    atomic_write_str(void_dir.join(MERGE_CONFLICTS), &conflicts_json)?;

    Ok(())
}

/// Clear all merge state files from the void directory.
///
/// This should be called after a merge is completed or aborted.
/// Silently ignores missing files.
pub fn clear_merge_state(void_dir: &Path) -> Result<()> {
    let files = [
        MERGE_HEAD,
        MERGE_BASE,
        MERGE_MSG,
        MERGE_CONFLICTS,
        ORIG_HEAD,
    ];

    for file in files {
        let path = void_dir.join(file);
        if path.exists() {
            fs::remove_file(&path)?;
        }
    }

    Ok(())
}

/// Check if a merge is in progress.
///
/// Returns true if MERGE_HEAD exists in the void directory.
pub fn is_merge_in_progress(void_dir: &Path) -> bool {
    void_dir.join(MERGE_HEAD).exists()
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    fn sample_state() -> MergeState {
        MergeState {
            merge_head: CommitCid::from_bytes(vec![0x01, 0x02, 0x03, 0x04]),
            merge_base: Some(CommitCid::from_bytes(vec![0x05, 0x06, 0x07, 0x08])),
            orig_head: CommitCid::from_bytes(vec![0x09, 0x0a, 0x0b, 0x0c]),
            conflicts: vec!["src/main.rs".to_string(), "README.md".to_string()],
            message: "Merge branch 'feature' into main".to_string(),
        }
    }

    #[test]
    fn write_read_roundtrip() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let state = sample_state();
        write_merge_state(void_dir, &state).unwrap();

        let read_state = read_merge_state(void_dir).unwrap().unwrap();

        assert_eq!(read_state.merge_head, state.merge_head);
        assert_eq!(read_state.merge_base, state.merge_base);
        assert_eq!(read_state.orig_head, state.orig_head);
        assert_eq!(read_state.conflicts, state.conflicts);
        assert_eq!(read_state.message, state.message);
    }

    #[test]
    fn write_read_roundtrip_no_base() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let mut state = sample_state();
        state.merge_base = None;
        write_merge_state(void_dir, &state).unwrap();

        let read_state = read_merge_state(void_dir).unwrap().unwrap();

        assert_eq!(read_state.merge_base, None);
    }

    #[test]
    fn write_read_roundtrip_empty_conflicts() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let mut state = sample_state();
        state.conflicts = Vec::new();
        write_merge_state(void_dir, &state).unwrap();

        let read_state = read_merge_state(void_dir).unwrap().unwrap();

        assert!(read_state.conflicts.is_empty());
    }

    #[test]
    fn clear_removes_all_files() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let state = sample_state();
        write_merge_state(void_dir, &state).unwrap();

        // Verify files exist
        assert!(void_dir.join(MERGE_HEAD).exists());
        assert!(void_dir.join(MERGE_BASE).exists());
        assert!(void_dir.join(MERGE_MSG).exists());
        assert!(void_dir.join(MERGE_CONFLICTS).exists());
        assert!(void_dir.join(ORIG_HEAD).exists());

        clear_merge_state(void_dir).unwrap();

        // Verify all files removed
        assert!(!void_dir.join(MERGE_HEAD).exists());
        assert!(!void_dir.join(MERGE_BASE).exists());
        assert!(!void_dir.join(MERGE_MSG).exists());
        assert!(!void_dir.join(MERGE_CONFLICTS).exists());
        assert!(!void_dir.join(ORIG_HEAD).exists());
    }

    #[test]
    fn clear_handles_missing_files() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        // Should not error when no files exist
        clear_merge_state(void_dir).unwrap();
    }

    #[test]
    fn is_merge_in_progress_true() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let state = sample_state();
        write_merge_state(void_dir, &state).unwrap();

        assert!(is_merge_in_progress(void_dir));
    }

    #[test]
    fn is_merge_in_progress_false() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        assert!(!is_merge_in_progress(void_dir));
    }

    #[test]
    fn is_merge_in_progress_after_clear() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let state = sample_state();
        write_merge_state(void_dir, &state).unwrap();
        assert!(is_merge_in_progress(void_dir));

        clear_merge_state(void_dir).unwrap();
        assert!(!is_merge_in_progress(void_dir));
    }

    #[test]
    fn read_when_no_merge_returns_none() {
        let temp = TempDir::new().unwrap();
        let void_dir = temp.path();

        let result = read_merge_state(void_dir).unwrap();
        assert!(result.is_none());
    }
}