governor_git/

commit.rs

//! Git commit wrapper

use governor_core::domain::commit::Commit;

/// Wrapper for Git commits
#[derive(Debug, Clone)]
pub struct GitCommit {
    inner: Commit,
}

impl GitCommit {
    /// Create a new Git commit wrapper
    #[must_use]
    pub const fn new(commit: Commit) -> Self {
        Self { inner: commit }
    }

    /// Get the inner commit
    #[must_use]
    pub const fn inner(&self) -> &Commit {
        &self.inner
    }

    /// Get the commit hash
    #[must_use]
    pub fn hash(&self) -> &str {
        &self.inner.hash
    }

    /// Get the short hash
    #[must_use]
    pub fn short_hash(&self) -> &str {
        &self.inner.short_hash
    }

    /// Get the commit message
    #[must_use]
    pub fn message(&self) -> &str {
        &self.inner.message
    }

    /// Get the author
    #[must_use]
    pub fn author(&self) -> &str {
        &self.inner.author
    }

    /// Check if this is a breaking change
    #[must_use]
    pub const fn is_breaking(&self) -> bool {
        self.inner.breaking
    }

    /// Get the commit type
    #[must_use]
    pub const fn commit_type(&self) -> Option<governor_core::domain::commit::CommitType> {
        self.inner.commit_type
    }

    /// Get the scope
    #[must_use]
    pub fn scope(&self) -> Option<&str> {
        self.inner.scope.as_deref()
    }
}

impl From<Commit> for GitCommit {
    fn from(commit: Commit) -> Self {
        Self::new(commit)
    }
}

impl From<GitCommit> for Commit {
    fn from(git_commit: GitCommit) -> Self {
        git_commit.inner
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use governor_core::domain::commit::CommitType;

    #[test]
    fn test_new() {
        let commit = Commit::new(
            "abc123".to_string(),
            "feat: test".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.hash(), "abc123");
    }

    #[test]
    fn test_inner() {
        let commit = Commit::new(
            "xyz789".to_string(),
            "fix: test".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.inner().hash, "xyz789");
    }

    #[test]
    fn test_hash() {
        let commit = Commit::new(
            "hash123".to_string(),
            "test".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.hash(), "hash123");
    }

    #[test]
    fn test_short_hash() {
        let commit = Commit::new(
            "12345678".to_string(),
            "test".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.short_hash(), "1234567");
    }

    #[test]
    fn test_message() {
        let commit = Commit::new(
            "hash".to_string(),
            "feat: new feature".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.message(), "feat: new feature");
    }

    #[test]
    fn test_author() {
        let commit = Commit::new(
            "hash".to_string(),
            "test".to_string(),
            "Jane Doe".to_string(),
            "jane@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.author(), "Jane Doe");
    }

    #[test]
    fn test_is_breaking_true() {
        let commit = Commit::new(
            "hash".to_string(),
            "feat!: breaking".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert!(git_commit.is_breaking());
    }

    #[test]
    fn test_is_breaking_false() {
        let commit = Commit::new(
            "hash".to_string(),
            "feat: normal".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert!(!git_commit.is_breaking());
    }

    #[test]
    fn test_commit_type() {
        let commit = Commit::new(
            "hash".to_string(),
            "feat: feature".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.commit_type(), Some(CommitType::Feat));
    }

    #[test]
    fn test_scope() {
        let commit = Commit::new(
            "hash".to_string(),
            "feat(api): endpoint".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit);
        assert_eq!(git_commit.scope(), Some("api"));
    }

    #[test]
    fn test_from_commit() {
        let commit = Commit::new(
            "hash".to_string(),
            "fix: bug".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::from(commit.clone());
        assert_eq!(git_commit.hash(), commit.hash);
    }

    #[test]
    fn test_into_commit() {
        let commit = Commit::new(
            "hash".to_string(),
            "fix: bug".to_string(),
            "Author".to_string(),
            "author@test.com".to_string(),
            Utc::now(),
        );
        let git_commit = GitCommit::new(commit.clone());
        let converted: Commit = git_commit.into();
        assert_eq!(converted.hash, commit.hash);
    }
}