git-mover 1.2.3

Move git repositories to a new location
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

//! This module contains the Platform trait and `PlatformType` enum.

use crate::{
    errors::GitMoverError,
    utils::{check_ssh_access, Repo},
};
use serde::Deserialize;
use std::pin::Pin;

/// The Platform trait is used to interact with different git platforms.
pub trait Platform: Sync + Send {
    /// Check git access
    fn check_git_access(
        &self,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<(), GitMoverError>> + Send + '_>> {
        let url_ssh = format!("git@{}", self.get_remote_url());
        Box::pin(async move {
            let (stdout, stderr) = check_ssh_access(&url_ssh).await?;
            if stdout.contains(self.get_username()) || stderr.contains(self.get_username()) {
                Ok(())
            } else {
                let stdout_str = if stdout.is_empty() {
                    ""
                } else {
                    &format!("stdout={} ", stdout.trim())
                };
                let stderr_str = if stderr.is_empty() {
                    ""
                } else {
                    &format!("stderr={} ", stderr.trim())
                };
                Err(GitMoverError::new(format!(
                    "Cannot access to {url_ssh}: {stdout_str}{stderr_str}for {}",
                    self.get_type()
                )))
            }
        })
    }

    /// Create a new repository on the platform.
    fn create_repo(
        &self,
        repo: Repo,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<(), GitMoverError>> + Send + '_>>;

    /// Get a repository from the platform.
    fn get_repo(
        &self,
        name: &str,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<Repo, GitMoverError>> + Send + '_>>;

    /// Edit a repository on the platform.
    fn edit_repo(
        &self,
        repo: Repo,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<(), GitMoverError>> + Send + '_>>;

    /// Get all repositories from the platform.
    fn get_all_repos(
        &self,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<Vec<Repo>, GitMoverError>> + Send>>;

    /// Delete a repository from the platform.
    fn delete_repo(
        &self,
        name: &str,
    ) -> Pin<Box<dyn std::future::Future<Output = Result<(), GitMoverError>> + Send + '_>>;

    /// Get the username of the platform.
    fn get_username(&self) -> &str;

    /// Get the platform type.
    fn get_remote_url(&self) -> String;

    /// get the type of the Platform
    fn get_type(&self) -> PlatformType;
}

/// The `PlatformType` enum is used to specify the platform type.
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub enum PlatformType {
    /// Gitlab platform
    Gitlab,

    /// Github platform
    Github,

    /// Codeberg platform
    Codeberg,
}

impl std::fmt::Display for PlatformType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PlatformType::Gitlab => write!(f, "gitlab"),
            PlatformType::Github => write!(f, "github"),
            PlatformType::Codeberg => write!(f, "codeberg"),
        }
    }
}

impl From<String> for PlatformType {
    fn from(s: String) -> Self {
        match s.to_lowercase().as_str() {
            "gitlab" => PlatformType::Gitlab,
            "github" => PlatformType::Github,
            "codeberg" => PlatformType::Codeberg,
            _ => panic!("Invalid platform"),
        }
    }
}