governor_git/

tag.rs

//! Git tag wrapper

use governor_core::domain::version::SemanticVersion;
use serde::{Deserialize, Serialize};

/// Wrapper for Git tags
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GitTag {
    /// Tag name
    pub name: String,
    /// Target commit hash
    pub target: String,
    /// Tag message
    pub message: Option<String>,
    /// Tagger
    pub tagger: Option<TaggerInfo>,
    /// Parsed version (if applicable)
    pub version: Option<SemanticVersion>,
}

impl GitTag {
    /// Create a new Git tag
    #[must_use]
    pub fn new(name: String, target: String) -> Self {
        let version = Self::parse_version(&name);

        Self {
            name,
            target,
            message: None,
            tagger: None,
            version,
        }
    }

    /// Parse version from tag name
    fn parse_version(name: &str) -> Option<SemanticVersion> {
        let version_str = name.trim_start_matches('v');
        SemanticVersion::parse(version_str).ok()
    }

    /// Set tag message
    #[must_use]
    pub fn with_message(mut self, message: String) -> Self {
        self.message = Some(message);
        self
    }

    /// Set tagger info
    #[must_use]
    pub fn with_tagger(mut self, tagger: TaggerInfo) -> Self {
        self.tagger = Some(tagger);
        self
    }

    /// Check if this is a version tag
    #[must_use]
    pub const fn is_version_tag(&self) -> bool {
        self.version.is_some()
    }

    /// Get the version
    #[must_use]
    pub const fn version(&self) -> Option<&SemanticVersion> {
        self.version.as_ref()
    }
}

/// Tagger information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaggerInfo {
    /// Name
    pub name: String,
    /// Email
    pub email: String,
    /// Timestamp
    pub timestamp: i64,
}

impl TaggerInfo {
    /// Create new tagger info
    #[must_use]
    pub const fn new(name: String, email: String, timestamp: i64) -> Self {
        Self {
            name,
            email,
            timestamp,
        }
    }
}

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

    #[test]
    fn test_new() {
        let tag = GitTag::new("v1.0.0".to_string(), "abc123".to_string());
        assert_eq!(tag.name, "v1.0.0");
        assert_eq!(tag.target, "abc123");
        assert!(tag.message.is_none());
        assert!(tag.tagger.is_none());
    }

    #[test]
    fn test_parse_version_with_v() {
        let tag = GitTag::new("v1.2.3".to_string(), "abc123".to_string());
        assert!(tag.version.is_some());
        assert_eq!(tag.version.as_ref().unwrap().to_string(), "1.2.3");
    }

    #[test]
    fn test_parse_version_without_v() {
        let tag = GitTag::new("2.0.0".to_string(), "abc123".to_string());
        assert!(tag.version.is_some());
        assert_eq!(tag.version.as_ref().unwrap().to_string(), "2.0.0");
    }

    #[test]
    fn test_parse_version_invalid() {
        let tag = GitTag::new("latest".to_string(), "abc123".to_string());
        assert!(tag.version.is_none());
    }

    #[test]
    fn test_parse_version_multiple_v() {
        let tag = GitTag::new("vv1.0.0".to_string(), "abc123".to_string());
        // trim_start_matches removes all 'v' from start
        assert!(tag.version.is_some());
        assert_eq!(tag.version.as_ref().unwrap().to_string(), "1.0.0");
    }

    #[test]
    fn test_with_message() {
        let tag = GitTag::new("v1.0.0".to_string(), "abc123".to_string())
            .with_message("Release".to_string());
        assert_eq!(tag.message, Some("Release".to_string()));
    }

    #[test]
    fn test_with_tagger() {
        let tagger = TaggerInfo::new("John".to_string(), "john@test.com".to_string(), 12345);
        let tag = GitTag::new("v1.0.0".to_string(), "abc123".to_string()).with_tagger(tagger);
        assert!(tag.tagger.is_some());
        assert_eq!(tag.tagger.as_ref().unwrap().name, "John");
    }

    #[test]
    fn test_is_version_tag_true() {
        let tag = GitTag::new("v1.0.0".to_string(), "abc123".to_string());
        assert!(tag.is_version_tag());
    }

    #[test]
    fn test_is_version_tag_false() {
        let tag = GitTag::new("stable".to_string(), "abc123".to_string());
        assert!(!tag.is_version_tag());
    }

    #[test]
    fn test_version_some() {
        let tag = GitTag::new("v3.2.1".to_string(), "abc123".to_string());
        assert!(tag.version().is_some());
        assert_eq!(tag.version().unwrap().to_string(), "3.2.1");
    }

    #[test]
    fn test_version_none() {
        let tag = GitTag::new("latest".to_string(), "abc123".to_string());
        assert!(tag.version().is_none());
    }

    #[test]
    fn test_tagger_info_new() {
        let tagger = TaggerInfo::new(
            "Alice".to_string(),
            "alice@test.com".to_string(),
            9_876_543_210,
        );
        assert_eq!(tagger.name, "Alice");
        assert_eq!(tagger.email, "alice@test.com");
        assert_eq!(tagger.timestamp, 9_876_543_210);
    }

    #[test]
    fn test_chained_builders() {
        let tagger = TaggerInfo::new("Bob".to_string(), "bob@test.com".to_string(), 1_111_111_111);
        let tag = GitTag::new("v2.0.0".to_string(), "def456".to_string())
            .with_message("Version 2.0.0".to_string())
            .with_tagger(tagger);

        assert_eq!(tag.name, "v2.0.0");
        assert_eq!(tag.message, Some("Version 2.0.0".to_string()));
        assert!(tag.tagger.is_some());
        assert_eq!(tag.tagger.as_ref().unwrap().name, "Bob");
    }

    #[test]
    fn test_serialize() {
        let tag = GitTag::new("v1.0.0".to_string(), "abc123".to_string());
        let json = serde_json::to_string(&tag);
        assert!(json.is_ok());
    }

    #[test]
    fn test_deserialize() {
        let json =
            r#"{"name":"v1.0.0","target":"abc123","message":null,"tagger":null,"version":null}"#;
        let tag: Result<GitTag, _> = serde_json::from_str(json);
        assert!(tag.is_ok());
        let tag = tag.unwrap();
        assert_eq!(tag.name, "v1.0.0");
        assert_eq!(tag.target, "abc123");
    }
}