ralph_workflow/git_helpers/

rebase.rs

//! Git rebase operations using libgit2.
//!
//! This module provides functionality to:
//! - Perform rebase operations onto a specified upstream branch
//! - Detect and report conflicts during rebase
//! - Abort an in-progress rebase
//! - Continue a rebase after conflict resolution
//! - Get lists of conflicted files
//!
//! All operations use libgit2 directly (not git CLI) for consistency
//! with the rest of the codebase.

#![deny(unsafe_code)]

use std::io;
use std::path::Path;

/// Convert git2 error to `io::Error`.
fn git2_to_io_error(err: &git2::Error) -> io::Error {
    io::Error::other(err.to_string())
}

/// Result of a rebase operation.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RebaseResult {
    /// Rebase completed successfully.
    Success,
    /// Rebase had conflicts that need resolution.
    Conflicts(Vec<String>),
    /// No rebase was needed (already up-to-date).
    NoOp,
}

/// Perform a rebase onto the specified upstream branch.
///
/// This function rebases the current branch onto the specified upstream branch.
/// It handles the full rebase process including conflict detection.
///
/// # Arguments
///
/// * `upstream_branch` - The branch to rebase onto (e.g., "main", "origin/main")
///
/// # Returns
///
/// Returns `Ok(RebaseResult)` indicating the outcome, or an error if:
/// - The repository cannot be opened
/// - The upstream branch cannot be found
/// - The rebase operation fails
///
/// # Edge Cases Handled
///
/// - Empty repository (no commits) - Returns `Ok(RebaseResult::NoOp)`
/// - Unborn branch - Returns `Ok(RebaseResult::NoOp)`
/// - Already up-to-date - Returns `Ok(RebaseResult::NoOp)`
/// - Unrelated branches (no shared ancestor) - Returns `Ok(RebaseResult::NoOp)`
/// - Conflicts during rebase - Returns `Ok(RebaseResult::Conflicts)`
///
/// # Note
///
/// This function uses git CLI for rebase operations as libgit2's rebase API
/// has limitations and complexity that make it unreliable for production use.
/// The git CLI is more robust and better tested for rebase operations.
pub fn rebase_onto(upstream_branch: &str) -> io::Result<RebaseResult> {
    use std::process::Command;

    // Check if we have any commits
    let repo = git2::Repository::discover(".").map_err(|e| git2_to_io_error(&e))?;

    match repo.head() {
        Ok(_) => {}
        Err(ref e) if e.code() == git2::ErrorCode::UnbornBranch => {
            // No commits yet - nothing to rebase
            return Ok(RebaseResult::NoOp);
        }
        Err(e) => return Err(git2_to_io_error(&e)),
    }

    // Get the upstream branch to ensure it exists
    let upstream_object = repo.revparse_single(upstream_branch).map_err(|_| {
        io::Error::new(
            io::ErrorKind::NotFound,
            format!("Upstream branch '{upstream_branch}' not found"),
        )
    })?;

    let upstream_commit = upstream_object
        .peel_to_commit()
        .map_err(|e| git2_to_io_error(&e))?;

    // Get our branch commit
    let head = repo.head().map_err(|e| git2_to_io_error(&e))?;
    let head_commit = head.peel_to_commit().map_err(|e| git2_to_io_error(&e))?;

    // Check if we're already up-to-date
    if repo
        .graph_descendant_of(head_commit.id(), upstream_commit.id())
        .map_err(|e| git2_to_io_error(&e))?
    {
        // Already up-to-date
        return Ok(RebaseResult::NoOp);
    }

    // Check if branches share a common ancestor
    // If merge_base fails with NotFound, the branches are unrelated
    match repo.merge_base(head_commit.id(), upstream_commit.id()) {
        Err(e)
            if e.class() == git2::ErrorClass::Reference
                && e.code() == git2::ErrorCode::NotFound =>
        {
            // Branches are unrelated - no shared history
            return Ok(RebaseResult::NoOp);
        }
        Err(e) => return Err(git2_to_io_error(&e)),
        Ok(_) => {}
    }

    // Check if we're on main/master
    let branch_name = head.shorthand().ok_or_else(|| {
        io::Error::new(
            io::ErrorKind::NotFound,
            "Could not determine branch name from HEAD",
        )
    })?;

    if branch_name == "main" || branch_name == "master" {
        return Ok(RebaseResult::NoOp);
    }

    // Use git CLI for rebase - more reliable than libgit2
    let output = Command::new("git")
        .args(["rebase", upstream_branch])
        .output();

    match output {
        Ok(result) => {
            if result.status.success() {
                Ok(RebaseResult::Success)
            } else {
                let stderr = String::from_utf8_lossy(&result.stderr);
                // Check if it's a conflict
                if stderr.contains("Conflict")
                    || stderr.contains("conflict")
                    || stderr.contains("Resolve")
                {
                    // Return empty conflict list - user can check with git status
                    Ok(RebaseResult::Conflicts(vec![]))
                } else if stderr.contains("up to date") {
                    Ok(RebaseResult::NoOp)
                } else {
                    Err(io::Error::other(format!("Rebase failed: {stderr}")))
                }
            }
        }
        Err(e) => Err(io::Error::other(format!(
            "Failed to execute git rebase: {e}"
        ))),
    }
}

/// Abort the current rebase operation.
///
/// This cleans up the rebase state and returns the repository to its
/// pre-rebase condition.
///
/// # Returns
///
/// Returns `Ok(())` if successful, or an error if:
/// - No rebase is in progress
/// - The abort operation fails
pub fn abort_rebase() -> io::Result<()> {
    use std::process::Command;

    let repo = git2::Repository::discover(".").map_err(|e| git2_to_io_error(&e))?;

    // Check if a rebase is in progress
    let state = repo.state();
    if state != git2::RepositoryState::Rebase
        && state != git2::RepositoryState::RebaseMerge
        && state != git2::RepositoryState::RebaseInteractive
    {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            "No rebase in progress",
        ));
    }

    // Use git CLI for abort
    let output = Command::new("git").args(["rebase", "--abort"]).output();

    match output {
        Ok(result) => {
            if result.status.success() {
                Ok(())
            } else {
                let stderr = String::from_utf8_lossy(&result.stderr);
                Err(io::Error::other(format!(
                    "Failed to abort rebase: {stderr}"
                )))
            }
        }
        Err(e) => Err(io::Error::other(format!(
            "Failed to execute git rebase --abort: {e}"
        ))),
    }
}

/// Get a list of files that have merge conflicts.
///
/// This function queries libgit2's index to find all files that are
/// currently in a conflicted state.
///
/// # Returns
///
/// Returns `Ok(Vec<String>)` containing the paths of conflicted files,
/// or an error if the repository cannot be accessed.
pub fn get_conflicted_files() -> io::Result<Vec<String>> {
    let repo = git2::Repository::discover(".").map_err(|e| git2_to_io_error(&e))?;
    let index = repo.index().map_err(|e| git2_to_io_error(&e))?;

    let mut conflicted_files = Vec::new();

    // Check if there are any conflicts
    if !index.has_conflicts() {
        return Ok(conflicted_files);
    }

    // Get the list of conflicted files
    let conflicts = index.conflicts().map_err(|e| git2_to_io_error(&e))?;

    for conflict in conflicts {
        let conflict = conflict.map_err(|e| git2_to_io_error(&e))?;
        // The conflict's `our` entry (stage 2) will have the path
        if let Some(our_entry) = conflict.our {
            if let Ok(path) = std::str::from_utf8(&our_entry.path) {
                let path_str = path.to_string();
                if !conflicted_files.contains(&path_str) {
                    conflicted_files.push(path_str);
                }
            }
        }
    }

    Ok(conflicted_files)
}

/// Extract conflict markers from a file.
///
/// This function reads a file and returns the conflict sections,
/// including both versions of the conflicted content.
///
/// # Arguments
///
/// * `path` - Path to the conflicted file (relative to repo root)
///
/// # Returns
///
/// Returns `Ok(String)` containing the conflict sections, or an error
/// if the file cannot be read.
pub fn get_conflict_markers_for_file(path: &Path) -> io::Result<String> {
    use std::fs;
    use std::io::Read;

    let mut file = fs::File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;

    // Extract conflict markers and their content
    let mut conflict_sections = Vec::new();
    let lines: Vec<&str> = content.lines().collect();
    let mut i = 0;

    while i < lines.len() {
        if lines[i].trim_start().starts_with("<<<<<<<") {
            // Found conflict start
            let mut section = Vec::new();
            section.push(lines[i]);

            i += 1;
            // Collect "ours" version
            while i < lines.len() && !lines[i].trim_start().starts_with("=======") {
                section.push(lines[i]);
                i += 1;
            }

            if i < lines.len() {
                section.push(lines[i]); // Add the ======= line
                i += 1;
            }

            // Collect "theirs" version
            while i < lines.len() && !lines[i].trim_start().starts_with(">>>>>>>") {
                section.push(lines[i]);
                i += 1;
            }

            if i < lines.len() {
                section.push(lines[i]); // Add the >>>>>>> line
                i += 1;
            }

            conflict_sections.push(section.join("\n"));
        } else {
            i += 1;
        }
    }

    if conflict_sections.is_empty() {
        // No conflict markers found, return empty string
        Ok(String::new())
    } else {
        Ok(conflict_sections.join("\n\n"))
    }
}

/// Continue a rebase after conflict resolution.
///
/// This function continues a rebase that was paused due to conflicts.
/// It should be called after all conflicts have been resolved and
/// the resolved files have been staged with `git add`.
///
/// # Returns
///
/// Returns `Ok(())` if successful, or an error if:
/// - No rebase is in progress
/// - Conflicts remain unresolved
/// - The continue operation fails
pub fn continue_rebase() -> io::Result<()> {
    use std::process::Command;

    let repo = git2::Repository::discover(".").map_err(|e| git2_to_io_error(&e))?;

    // Check if a rebase is in progress
    let state = repo.state();
    if state != git2::RepositoryState::Rebase
        && state != git2::RepositoryState::RebaseMerge
        && state != git2::RepositoryState::RebaseInteractive
    {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            "No rebase in progress",
        ));
    }

    // Check if there are still conflicts
    let conflicted = get_conflicted_files()?;
    if !conflicted.is_empty() {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            format!(
                "Cannot continue rebase: {} file(s) still have conflicts",
                conflicted.len()
            ),
        ));
    }

    // Use git CLI for continue
    let output = Command::new("git").args(["rebase", "--continue"]).output();

    match output {
        Ok(result) => {
            if result.status.success() {
                Ok(())
            } else {
                let stderr = String::from_utf8_lossy(&result.stderr);
                Err(io::Error::other(format!(
                    "Failed to continue rebase: {stderr}"
                )))
            }
        }
        Err(e) => Err(io::Error::other(format!(
            "Failed to execute git rebase --continue: {e}"
        ))),
    }
}

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

    #[test]
    fn test_rebase_result_variants_exist() {
        // Test that RebaseResult has the expected variants
        let _ = RebaseResult::Success;
        let _ = RebaseResult::NoOp;
        let _ = RebaseResult::Conflicts(vec![]);
    }

    #[test]
    fn test_rebase_onto_returns_result() {
        // Test that rebase_onto returns a Result
        // We use a non-existent branch to test error handling
        let result = rebase_onto("nonexistent_branch_that_does_not_exist");
        // Should fail because the branch doesn't exist
        assert!(result.is_err());
    }

    #[test]
    fn test_get_conflicted_files_returns_result() {
        // Test that get_conflicted_files returns a Result
        let result = get_conflicted_files();
        // Should succeed (returns Vec, not error)
        assert!(result.is_ok());
    }
}