use std::sync::OnceLock;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Forge {
GitHub,
GitLab,
Forgejo,
Entire,
}
impl Forge {
pub fn parse(kind: &str) -> Option<Self> {
match kind.to_ascii_lowercase().as_str() {
"github" => Some(Self::GitHub),
"gitlab" => Some(Self::GitLab),
"forgejo" | "gitea" => Some(Self::Forgejo),
_ => None,
}
}
pub fn name(self) -> &'static str {
match self {
Self::GitHub => "GitHub",
Self::GitLab => "GitLab",
Self::Forgejo => "Forgejo",
Self::Entire => "Entire",
}
}
fn api_url_var(self) -> Option<&'static str> {
match self {
Self::GitHub => Some("JOUET_GITHUB_API_URL"),
Self::GitLab => Some("JOUET_GITLAB_API_URL"),
Self::Forgejo => Some("JOUET_FORGEJO_API_URL"),
Self::Entire => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Configured {
pub host: String,
pub forge: Forge,
pub api_url: Option<String>,
pub token_env: Option<String>,
}
static LOADER: OnceLock<fn() -> Vec<Configured>> = OnceLock::new();
static CONFIGURED: OnceLock<Vec<Configured>> = OnceLock::new();
pub fn configure(load: fn() -> Vec<Configured>) {
let _ = LOADER.set(load);
}
fn configured(host: &str) -> Option<&'static Configured> {
let hosts = CONFIGURED.get_or_init(|| {
let load = LOADER.get().map_or_else(Vec::new, |load| load());
load.into_iter()
.map(|mut h| {
h.host = normalize(&h.host);
h
})
.collect()
});
hosts.iter().find(|c| c.host == host)
}
pub(crate) fn normalize(host: &str) -> String {
let host = host.trim().trim_end_matches('.').to_ascii_lowercase();
let host = host
.strip_prefix("www.")
.map_or(host.clone(), str::to_string);
match host.as_str() {
"ssh.github.com" => "github.com".into(),
"altssh.gitlab.com" => "gitlab.com".into(),
"entire.io" => "entire.com".into(),
h if h.ends_with(".entire.io") => "entire.com".into(),
_ => host,
}
}
pub fn of_host(host: &str) -> Option<Forge> {
let host = normalize(host);
match host.as_str() {
"github.com" => Some(Forge::GitHub),
"gitlab.com" => Some(Forge::GitLab),
"codeberg.org" | "gitea.com" => Some(Forge::Forgejo),
"entire.com" => Some(Forge::Entire),
_ => configured(&host).map(|c| c.forge),
}
}
pub(crate) fn token_vars(forge: Forge, host: &str) -> Vec<String> {
let host = normalize(host);
let mut vars: Vec<String> = configured(&host)
.and_then(|c| c.token_env.clone())
.into_iter()
.collect();
let gitlab_host = std::env::var("GITLAB_HOST")
.ok()
.map(|h| {
let h = h.split_once("://").map_or(h.as_str(), |(_, rest)| rest);
normalize(h.split('/').next().unwrap_or_default())
})
.filter(|h| !h.is_empty())
.unwrap_or_else(|| "gitlab.com".into());
let shared: &[(&str, &str)] = match forge {
Forge::GitLab => &[
("JOUET_GITLAB_TOKEN", &gitlab_host),
("GITLAB_TOKEN", &gitlab_host),
("GITLAB_ACCESS_TOKEN", &gitlab_host),
],
Forge::Forgejo => &[
("JOUET_FORGEJO_TOKEN", "codeberg.org"),
("FORGEJO_TOKEN", "codeberg.org"),
("GITEA_TOKEN", "gitea.com"),
],
Forge::GitHub | Forge::Entire => &[],
};
vars.extend(
shared
.iter()
.filter(|(_, owner)| *owner == host)
.map(|(var, _)| (*var).to_string()),
);
vars
}
pub fn unknown(host: &str) -> String {
format!(
"jouet does not know which forge {host} runs; name it in jouet's config: \
[forges.\"{host}\"] kind = \"gitlab\" (or \"forgejo\")"
)
}
pub(crate) fn api_url(forge: Forge, host: &str) -> String {
if let Some(url) = forge
.api_url_var()
.and_then(|var| std::env::var(var).ok())
.filter(|u| !u.is_empty())
{
return url.trim_end_matches('/').to_string();
}
if let Some(url) = configured(host).and_then(|c| c.api_url.clone()) {
return url.trim_end_matches('/').to_string();
}
match forge {
Forge::GitHub => "https://api.github.com".into(),
Forge::GitLab => format!("https://{host}/api/v4"),
Forge::Forgejo => format!("https://{host}/api/v1"),
Forge::Entire => format!("https://{host}"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn known_hosts_need_no_config() {
assert_eq!(of_host("github.com"), Some(Forge::GitHub));
assert_eq!(of_host("GitLab.com"), Some(Forge::GitLab));
assert_eq!(of_host("www.codeberg.org"), Some(Forge::Forgejo));
assert_eq!(of_host("git.example.com"), None);
assert_eq!(of_host("entire.com"), Some(Forge::Entire));
assert_eq!(of_host("aws-us-east-2.entire.io"), Some(Forge::Entire));
assert_eq!(normalize("aws-eu-central-1.entire.io"), "entire.com");
}
#[test]
fn shared_token_variables_belong_to_one_host() {
assert_eq!(
token_vars(Forge::Forgejo, "codeberg.org"),
["JOUET_FORGEJO_TOKEN", "FORGEJO_TOKEN"]
);
assert_eq!(token_vars(Forge::Forgejo, "gitea.com"), ["GITEA_TOKEN"]);
assert!(token_vars(Forge::Forgejo, "git.example.com").is_empty());
}
#[test]
fn kinds_parse_with_gitea_as_forgejo() {
assert_eq!(Forge::parse("GitLab"), Some(Forge::GitLab));
assert_eq!(Forge::parse("gitea"), Some(Forge::Forgejo));
assert_eq!(Forge::parse("bitbucket"), None);
}
}