gitgrip 1.0.0

Multi-repo workflow tool - manage multiple git repositories as one
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Platform capability declarations
//!
//! Documents which optional operations each hosting platform supports,
//! allowing callers to check capability before attempting an operation.

use crate::core::manifest::PlatformType;

/// Optional capabilities that a hosting platform may support
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PlatformCapability {
    /// Create a pull/merge request
    CreatePr,
    /// Merge a pull/merge request
    MergePr,
    /// Find an open PR by branch name
    FindPrByBranch,
    /// Get PR review status
    GetReviews,
    /// Get CI/CD status checks
    StatusChecks,
    /// Get allowed merge methods
    MergeMethods,
    /// Get PR diff
    PrDiff,
    /// Update a PR branch (merge base into head)
    UpdateBranch,
    /// Enable auto-merge when checks pass
    AutoMerge,
    /// Create a repository on the platform
    CreateRepo,
    /// Delete a repository from the platform
    DeleteRepo,
    /// Create a tagged release
    CreateRelease,
}

/// Returns the capabilities supported by the given platform type.
///
/// Core PR operations (create, merge, find, reviews, checks, diff, merge methods)
/// are implemented by all platforms. Optional operations vary.
pub fn platform_capabilities(platform: PlatformType) -> Vec<PlatformCapability> {
    use PlatformCapability::*;

    // All platforms support core PR operations
    let mut caps = vec![
        CreatePr,
        MergePr,
        FindPrByBranch,
        GetReviews,
        StatusChecks,
        MergeMethods,
        PrDiff,
    ];

    match platform {
        PlatformType::GitHub => {
            caps.extend([
                UpdateBranch,
                AutoMerge,
                CreateRepo,
                DeleteRepo,
                CreateRelease,
            ]);
        }
        PlatformType::GitLab => {
            caps.extend([CreateRepo, DeleteRepo]);
        }
        PlatformType::AzureDevOps => {
            caps.extend([CreateRepo, DeleteRepo]);
        }
        PlatformType::Bitbucket => {
            // Bitbucket only supports core PR operations
        }
    }

    caps
}

/// Check if a platform supports a specific capability
pub fn platform_supports(platform: PlatformType, capability: PlatformCapability) -> bool {
    platform_capabilities(platform).contains(&capability)
}

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

    #[test]
    fn test_github_has_all_capabilities() {
        let caps = platform_capabilities(PlatformType::GitHub);
        assert!(caps.contains(&PlatformCapability::CreatePr));
        assert!(caps.contains(&PlatformCapability::AutoMerge));
        assert!(caps.contains(&PlatformCapability::UpdateBranch));
        assert!(caps.contains(&PlatformCapability::CreateRepo));
        assert!(caps.contains(&PlatformCapability::DeleteRepo));
        assert!(caps.contains(&PlatformCapability::CreateRelease));
    }

    #[test]
    fn test_gitlab_has_repo_management() {
        let caps = platform_capabilities(PlatformType::GitLab);
        assert!(caps.contains(&PlatformCapability::CreatePr));
        assert!(caps.contains(&PlatformCapability::CreateRepo));
        assert!(caps.contains(&PlatformCapability::DeleteRepo));
        assert!(!caps.contains(&PlatformCapability::AutoMerge));
        assert!(!caps.contains(&PlatformCapability::CreateRelease));
    }

    #[test]
    fn test_azure_has_repo_management() {
        let caps = platform_capabilities(PlatformType::AzureDevOps);
        assert!(caps.contains(&PlatformCapability::CreatePr));
        assert!(caps.contains(&PlatformCapability::CreateRepo));
        assert!(!caps.contains(&PlatformCapability::AutoMerge));
    }

    #[test]
    fn test_bitbucket_core_only() {
        let caps = platform_capabilities(PlatformType::Bitbucket);
        assert!(caps.contains(&PlatformCapability::CreatePr));
        assert!(caps.contains(&PlatformCapability::MergePr));
        assert!(!caps.contains(&PlatformCapability::CreateRepo));
        assert!(!caps.contains(&PlatformCapability::AutoMerge));
        assert!(!caps.contains(&PlatformCapability::CreateRelease));
    }

    #[test]
    fn test_platform_supports() {
        assert!(platform_supports(
            PlatformType::GitHub,
            PlatformCapability::AutoMerge
        ));
        assert!(!platform_supports(
            PlatformType::Bitbucket,
            PlatformCapability::AutoMerge
        ));
    }
}