governor_git/

adapter.rs

//! Git adapter implementation

use async_trait::async_trait;
use chrono::{DateTime, TimeZone, Utc};
use git2::{Oid, Repository, StatusOptions, Time};
use std::path::{Path, PathBuf};
use std::sync::{Arc, Mutex};

use governor_core::domain::commit::Commit;
use governor_core::domain::version::SemanticVersion;
use governor_core::domain::workspace::WorkingTreeStatus;
use governor_core::traits::source_control::{ScmConfig, ScmError, SourceControl};

/// Git adapter configuration
#[derive(Debug, Clone)]
pub struct GitAdapterConfig {
    /// Path to repository
    pub repository_path: Option<PathBuf>,
    /// Remote name
    pub default_remote: String,
    /// Whether to sign commits
    pub sign_commits: bool,
    /// Whether to sign tags
    pub sign_tags: bool,
    /// Commit message template
    pub commit_template: Option<String>,
    /// Tag name template
    pub tag_template: Option<String>,
}

impl Default for GitAdapterConfig {
    fn default() -> Self {
        Self {
            repository_path: None,
            default_remote: "origin".to_string(),
            sign_commits: false,
            sign_tags: false,
            commit_template: Some("chore(release): bump version to {{version}}".to_string()),
            tag_template: Some("v{{version}}".to_string()),
        }
    }
}

impl From<ScmConfig> for GitAdapterConfig {
    fn from(config: ScmConfig) -> Self {
        Self {
            repository_path: config.repository_path,
            default_remote: config.default_remote,
            sign_commits: config.sign_commits,
            sign_tags: config.sign_tags,
            commit_template: config.commit_template,
            tag_template: config.tag_template,
        }
    }
}

/// Git adapter implementation
pub struct GitAdapter {
    repo: Arc<Mutex<Repository>>,
    config: GitAdapterConfig,
}

// Safety: GitAdapter uses Arc<Mutex<>> to provide thread-safe access
// The unsafe impl is no longer needed since Arc<Mutex<T>> provides Sync automatically
// when T is Send, which Repository is

impl GitAdapter {
    /// Open a Git repository at the given path or current directory
    ///
    /// # Errors
    ///
    /// Returns `ScmError` if the repository cannot be discovered or opened
    pub fn open(config: GitAdapterConfig) -> Result<Self, ScmError> {
        let path = config
            .repository_path
            .clone()
            .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")));

        let repo = Repository::discover(&path)
            .map_err(|e| ScmError::NotFound(format!("Failed to discover git repo: {e}")))?;

        Ok(Self {
            repo: Arc::new(Mutex::new(repo)),
            config,
        })
    }

    /// Get the underlying git2 repository
    #[must_use]
    pub fn repository(&self) -> Arc<Mutex<Repository>> {
        Arc::clone(&self.repo)
    }

    /// Helper to execute a function with repository access
    fn with_repo<F, R>(&self, f: F) -> R
    where
        F: FnOnce(&Repository) -> R,
    {
        let repo = self.repo.lock().unwrap();
        f(&repo)
    }

    /// Resolve a git reference to its target OID.
    ///
    /// This helper handles both lightweight and annotated tags:
    /// - Lightweight tags: Direct reference to a commit
    /// - Annotated tags: Tag object that points to a commit
    ///
    /// # Arguments
    ///
    /// * `repo` - The git repository
    /// * `reference_name` - The name of the reference (e.g., "v1.0.0", "refs/tags/v1.0.0")
    ///
    /// # Returns
    ///
    /// Returns `Some(Oid)` if the reference can be resolved, `None` otherwise.
    ///
    /// # Errors
    ///
    /// Returns `ScmError` if the reference cannot be found or resolved.
    fn resolve_reference_target(
        repo: &Repository,
        reference_name: &str,
    ) -> Result<Option<git2::Oid>, ScmError> {
        // Try to find the reference - works for both full refs and short names
        let reference = repo
            .find_reference(reference_name)
            .or_else(|_| repo.resolve_reference_from_short_name(reference_name))
            .map_err(|e| {
                ScmError::GitError(format!(
                    "Failed to resolve git reference `{reference_name}`: {e}. \
                    Ensure the reference exists in the repository."
                ))
            })?;

        // Get the target OID - for lightweight tags it's the commit,
        // for annotated tags we need to peel to get the actual commit
        let target_oid = reference
            .peel_to_tag()
            .ok()
            .map(|tag_obj| tag_obj.target_id())
            .or_else(|| {
                reference.peel(git2::ObjectType::Any).ok().and_then(|obj| {
                    obj.as_commit()
                        .map(git2::Commit::id)
                        .or_else(|| obj.as_tag().map(git2::Tag::target_id))
                        .or_else(|| Some(obj.id()))
                })
            });

        Ok(target_oid)
    }

    /// Convert git2 time to `DateTime`
    fn git_time_to_datetime(time: &Time) -> DateTime<Utc> {
        Utc.timestamp_opt(time.seconds(), 0).unwrap()
    }

    /// Parse commit from git2 commit object
    fn parse_commit(commit: &git2::Commit) -> Commit {
        Commit::new(
            commit.id().to_string(),
            commit.message().unwrap_or("").to_string(),
            commit.author().name().unwrap_or("").to_string(),
            commit.author().email().unwrap_or("").to_string(),
            Self::git_time_to_datetime(&commit.time()),
        )
    }

    /// Get the repository root path
    #[must_use]
    pub fn repo_root(&self) -> PathBuf {
        self.with_repo(|repo| {
            repo.workdir()
                .map_or_else(|| PathBuf::from("."), std::path::Path::to_path_buf)
        })
    }
}

#[async_trait]
impl SourceControl for GitAdapter {
    fn name(&self) -> &'static str {
        "git"
    }

    async fn get_commits_since(&self, tag: Option<&str>) -> Result<Vec<Commit>, ScmError> {
        // First, get the end_oid synchronously
        let (start_oid_str, end_oid_str, _tag_name) = self.with_repo(|repo| {
            let head = repo.head().map_err(|e| ScmError::GitError(e.to_string()))?;

            let start_oid = head.target().ok_or(ScmError::NoCommits)?;

            let tag_name = tag.map(std::string::ToString::to_string);

            // If we have a tag, find its target oid now
            let end_oid_str = if let Some(tag_name) = &tag_name {
                let target_oid = Self::resolve_reference_target(repo, tag_name).map_err(|_| {
                    ScmError::TagNotFound(format!("Tag `{tag_name}` not found in repository"))
                })?;

                Some(
                    target_oid
                        .map(|id: git2::Oid| id.to_string())
                        .unwrap_or_default(),
                )
            } else {
                None
            };

            Ok::<(String, Option<String>, Option<String>), ScmError>((
                start_oid.to_string(),
                end_oid_str,
                tag_name,
            ))
        })?;

        // If no tag provided, find the previous tag asynchronously
        let end_oid_str = if end_oid_str.is_none() {
            match self.get_last_tag(None).await {
                Ok(Some(prev_tag)) => self.with_repo(|repo| {
                    let target_oid =
                        Self::resolve_reference_target(repo, &prev_tag).map_err(|e| {
                            ScmError::GitError(format!(
                                "Failed to resolve tag `{prev_tag}` while finding commits: {e}"
                            ))
                        })?;

                    Ok::<Option<String>, ScmError>(target_oid.map(|id: git2::Oid| id.to_string()))
                })?,
                _ => None,
            }
        } else {
            end_oid_str
        };

        // Now collect all commits synchronously
        let commits = self.with_repo(|repo| {
            let start_oid = git2::Oid::from_str(&start_oid_str)
                .map_err(|e| ScmError::GitError(e.to_string()))?;

            let end_oid = end_oid_str
                .as_ref()
                .and_then(|s| git2::Oid::from_str(s).ok());

            let mut revwalk = repo
                .revwalk()
                .map_err(|e| ScmError::GitError(e.to_string()))?;

            revwalk
                .push(start_oid)
                .map_err(|e| ScmError::GitError(e.to_string()))?;

            let mut result = Vec::new();

            for oid in revwalk {
                let oid = oid.map_err(|e| ScmError::GitError(e.to_string()))?;

                // Stop at end commit
                if let Some(end) = end_oid
                    && oid == end
                {
                    break;
                }

                let commit = repo
                    .find_commit(oid)
                    .map_err(|e| ScmError::GitError(e.to_string()))?;

                result.push(Self::parse_commit(&commit));
            }

            Ok::<Vec<Commit>, ScmError>(result)
        })?;

        Ok(commits)
    }

    async fn get_last_tag(&self, pattern: Option<&str>) -> Result<Option<String>, ScmError> {
        let tags = self.with_repo(|repo| {
            let tag_names = repo
                .tag_names(None)
                .map_err(|e| ScmError::GitError(e.to_string()))?;

            let pattern_re = pattern.map(|p| regex::Regex::new(&format!("^{p}")).unwrap());

            let mut tags: Vec<String> = tag_names
                .iter()
                .filter_map(|t| t.map(std::string::ToString::to_string))
                .filter(|t| pattern_re.as_ref().is_none_or(|re| re.is_match(t)))
                .collect();

            // Sort by version (descending)
            tags.sort_by(|a, b| {
                let v_a = SemanticVersion::parse(a.trim_start_matches('v'));
                let v_b = SemanticVersion::parse(b.trim_start_matches('v'));
                match (v_a, v_b) {
                    (Ok(va), Ok(vb)) => vb.version.cmp(&va.version),
                    _ => b.cmp(a),
                }
            });

            Ok::<Vec<String>, ScmError>(tags)
        })?;

        Ok(tags.into_iter().next())
    }

    async fn create_tag(&self, name: &str, message: &str) -> Result<String, ScmError> {
        self.with_repo(|repo| {
            let head = repo
                .head()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let target = head
                .peel_to_commit()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let sig = repo
                .signature()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let _oid = repo
                .tag(
                    name,
                    target.as_object(),
                    &sig,
                    message,
                    self.config.sign_tags,
                )
                .map_err(|e: git2::Error| {
                    ScmError::GitError(format!("Failed to create tag: {e}"))
                })?;

            Ok::<(), ScmError>(())
        })?;

        Ok(name.to_string())
    }

    async fn delete_tag(&self, name: &str) -> Result<(), ScmError> {
        self.with_repo(|repo| {
            let mut reference = repo
                .find_reference(&format!("refs/tags/{name}"))
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            reference
                .delete()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            Ok::<(), ScmError>(())
        })
    }

    async fn get_current_commit(&self) -> Result<String, ScmError> {
        self.with_repo(|repo| {
            let head = repo
                .head()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            Ok::<String, ScmError>(head.target().ok_or(ScmError::NoCommits)?.to_string())
        })
    }

    async fn get_current_branch(&self) -> Result<String, ScmError> {
        self.with_repo(|repo| {
            let head = repo
                .head()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let branch = if head.is_branch() {
                head.shorthand().unwrap_or("unknown").to_string()
            } else {
                "HEAD".to_string()
            };

            Ok::<String, ScmError>(branch)
        })
    }

    async fn get_working_tree_status(&self) -> Result<WorkingTreeStatus, ScmError> {
        self.with_repo(|repo| {
            let mut status_opts = StatusOptions::new();
            status_opts
                .include_untracked(true)
                .recurse_untracked_dirs(true);

            let statuses = repo
                .statuses(Some(&mut status_opts))
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let mut working_tree = WorkingTreeStatus {
                has_changes: false,
                modified: Vec::new(),
                added: Vec::new(),
                deleted: Vec::new(),
                untracked: Vec::new(),
            };

            for entry in statuses.iter() {
                let path = entry.path().unwrap_or("").to_string();
                let status = entry.status();

                if status.is_index_new() || status.is_wt_new() {
                    working_tree.untracked.push(path.clone());
                }
                if status.is_index_modified() || status.is_wt_modified() {
                    working_tree.modified.push(path.clone());
                }
                if status.is_index_deleted() || status.is_wt_deleted() {
                    working_tree.deleted.push(path.clone());
                }
                if status.is_index_renamed() || status.is_wt_renamed() {
                    working_tree.added.push(path);
                }
            }

            working_tree.has_changes = !working_tree.modified.is_empty()
                || !working_tree.added.is_empty()
                || !working_tree.deleted.is_empty()
                || !working_tree.untracked.is_empty();

            Ok::<WorkingTreeStatus, ScmError>(working_tree)
        })
    }

    async fn commit(&self, message: &str, files: &[String]) -> Result<String, ScmError> {
        let files_to_check: Vec<PathBuf> = files
            .iter()
            .filter_map(|f| {
                let p = Path::new(f);
                if p.exists() {
                    Some(p.to_path_buf())
                } else {
                    None
                }
            })
            .collect();

        self.with_repo(|repo| {
            let mut index = repo
                .index()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            // Stage files
            for path in &files_to_check {
                index
                    .add_path(path)
                    .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;
            }

            index
                .write()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let tree_id = index
                .write_tree()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let tree = repo
                .find_tree(tree_id)
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            // Get current HEAD as parent
            let head = repo
                .head()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;
            let parent_commit = head
                .peel_to_commit()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let sig = repo
                .signature()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            let oid = repo
                .commit(Some("HEAD"), &sig, &sig, message, &tree, &[&parent_commit])
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            Ok::<String, ScmError>(oid.to_string())
        })
    }

    async fn stage_files(&self, files: &[String]) -> Result<(), ScmError> {
        let files_to_stage: Vec<PathBuf> = files
            .iter()
            .filter_map(|f| {
                let p = Path::new(f);
                if p.exists() {
                    Some(p.to_path_buf())
                } else {
                    None
                }
            })
            .collect();

        self.with_repo(|repo| {
            let mut index = repo
                .index()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            for path in &files_to_stage {
                index
                    .add_path(path)
                    .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;
            }

            index
                .write()
                .map_err(|e: git2::Error| ScmError::GitError(e.to_string()))?;

            Ok::<(), ScmError>(())
        })
    }

    async fn push(&self, remote: Option<&str>, branch: Option<&str>) -> Result<(), ScmError> {
        let remote_name = remote.unwrap_or(&self.config.default_remote).to_string();
        let branch_name = branch.unwrap_or("main").to_string();

        self.with_repo(|repo| {
            let mut remote_obj = repo
                .find_remote(&remote_name)
                .map_err(|_| ScmError::GitError(format!("Remote '{remote_name}' not found")))?;

            let branch_ref = format!("refs/heads/{branch_name}");

            remote_obj
                .push(&[&branch_ref], None)
                .map_err(|e: git2::Error| ScmError::GitError(format!("Push failed: {e}")))?;

            Ok::<(), ScmError>(())
        })
    }

    fn repository_root(&self) -> Option<&Path> {
        // Note: This method signature requires returning a reference tied to self,
        // but we can't return a reference from inside the Mutex guard.
        // This is a known limitation - for now we'll return None.
        // A proper fix would require changing the trait to return PathBuf or similar.
        None
    }

    async fn is_on_branch(&self, branch: &str) -> Result<bool, ScmError> {
        let current = self.get_current_branch().await?;
        Ok(current == branch)
    }

    async fn get_tags_for_commit(&self, commit_hash: &str) -> Result<Vec<String>, ScmError> {
        let oid = Oid::from_str(commit_hash)
            .map_err(|e| ScmError::GitError(format!("Invalid commit hash `{commit_hash}`: {e}")))?;

        self.with_repo(|repo| {
            let tag_names = repo
                .tag_names(None)
                .map_err(|e| ScmError::GitError(format!("Failed to get tag names: {e}")))?;

            let mut tags = Vec::new();

            for tag_name in tag_names.iter().flatten() {
                if let Ok(Some(target_oid)) = Self::resolve_reference_target(repo, tag_name)
                    && target_oid == oid
                {
                    tags.push(tag_name.to_string());
                }
            }

            Ok::<Vec<String>, ScmError>(tags)
        })
    }

    async fn get_remote_url(&self, remote: Option<&str>) -> Result<Option<String>, ScmError> {
        let remote_name = remote.unwrap_or(&self.config.default_remote).to_string();

        self.with_repo(|repo| {
            let remote_obj = repo
                .find_remote(&remote_name)
                .map_err(|_| ScmError::GitError(format!("Remote '{remote_name}' not found")))?;

            Ok::<Option<String>, ScmError>(remote_obj.url().map(String::from))
        })
    }
}

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

    #[test]
    fn test_git_adapter_config_default() {
        let config = GitAdapterConfig::default();
        assert_eq!(config.default_remote, "origin");
        assert!(!config.sign_commits);
        assert!(!config.sign_tags);
    }
}