bleur 0.0.7

That buddy that will get everything ready for you
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

use std::path::Path;

use crate::{Error, Result};
use git2::{FetchOptions, Repository, build::RepoBuilder};
use url::Url;

pub enum Provider {
    Branch {
        provider: String,
        owner: String,
        repo: String,
        branch: String,
    },
    Branchless {
        provider: String,
        owner: String,
        repo: String,
    },
    Other {
        url: String,
    },
}

fn provider_link(scheme: String, owner: String, repo: String) -> Result<String> {
    Ok(match scheme.as_str() {
        "github" => format!("https://github.com/{owner}/{repo}"),
        "codeberg" => format!("https://codeberg.org/{owner}/{repo}"),
        // I won't support GitLab's obscure format, it's too unpredictable
        _ => return Err(Error::UnknownGitProvider(scheme.to_owned())),
    })
}

impl Provider {
    pub fn from_url(url: Url) -> Result<Self> {
        // example:owner/repo/branch
        // ---^---------------------
        if url.scheme() == "https" || url.scheme() == "http" {
            return Ok(Self::Other {
                url: url.to_string(),
            });
        }

        let path: Vec<String> = url.path().split('/').map(|i| i.to_owned()).collect();

        // example:owner/repo/branch
        // ----------^--------------
        let owner = path
            .first()
            .map(|p| p.to_owned())
            .ok_or(Error::InvalidRepositoryOwner(url.to_string()))?;

        // example:owner/repo/branch
        // ---------------^---------
        let repo = path
            .get(1)
            .map(|p| p.to_owned())
            .ok_or(Error::InvalidRepositoryName(url.to_string()))?;

        // example:owner/repo/branch
        // ---------------------^---
        let branch = path.get(2).map(|p| p.to_owned());

        Ok(match branch {
            Some(b) => Self::Branch {
                repo,
                owner,
                branch: b,
                provider: url.scheme().to_owned(),
            },
            None => Self::Branchless {
                repo,
                owner,
                provider: url.scheme().to_owned(),
            },
        })
    }

    pub fn fetch_repo(self, options: FetchOptions, path: &Path) -> Result<Repository> {
        match self {
            Self::Branch {
                provider,
                owner,
                repo,
                branch,
            } => RepoBuilder::new()
                .fetch_options(options)
                .branch(&branch)
                .clone(&provider_link(provider, owner, repo)?, path)
                .map_err(Error::GitError),
            Self::Branchless {
                provider,
                owner,
                repo,
            } => RepoBuilder::new()
                .fetch_options(options)
                .clone(&provider_link(provider, owner, repo)?, path)
                .map_err(Error::GitError),
            Self::Other { url } => RepoBuilder::new()
                .fetch_options(options)
                .clone(&url, path)
                .map_err(Error::GitError),
        }
    }
}