use std::{fs, path::Path, process::Command};
use toml_edit::DocumentMut;
use crate::workspace;
#[must_use]
pub fn forge_from_url(url: &str) -> Option<&'static str> {
if url.contains("github.com") {
Some("github")
} else if url.contains("gitlab.com") {
Some("gitlab")
} else if url.contains("codeberg.org") {
Some("forgejo")
} else if url.contains("gitea.com") {
Some("gitea")
} else {
None
}
}
#[must_use]
pub fn language_from_files(files: &[&str]) -> Option<&'static str> {
if files.contains(&"Cargo.toml") {
Some("cargo")
} else if files.contains(&"package.json") {
Some("npm")
} else if files.contains(&"go.mod") {
Some("go")
} else {
None
}
}
#[must_use]
pub fn remote_url(root: &Path) -> Option<String> {
Command::new("git")
.args(["remote", "get-url", "origin"])
.current_dir(root)
.output()
.ok()
.filter(|o| o.status.success())
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_owned())
}
pub fn root_files(root: &Path) -> Vec<String> {
fs::read_dir(root)
.into_iter()
.flatten()
.filter_map(Result::ok)
.filter_map(|e| e.file_name().into_string().ok())
.collect()
}
#[must_use]
pub fn tool_available(name: &str) -> bool {
which::which(name).is_ok()
}
pub fn detect_forge(root: &Path) -> Option<&'static str> {
remote_url(root).as_deref().and_then(forge_from_url)
}
pub fn detect_language(root: &Path) -> Option<&'static str> {
let files = root_files(root);
let file_refs: Vec<&str> = files.iter().map(String::as_str).collect();
language_from_files(&file_refs)
}
#[must_use]
pub fn detect_versioning(workspace_toml: &Path) -> &'static str {
let Ok(members) = workspace::parse_workspace_members(workspace_toml) else {
return "unified";
};
let Some(workspace_dir) = workspace_toml.parent() else {
return "unified";
};
for member in &members {
let member_toml = workspace_dir.join(&member.path).join("Cargo.toml");
let Ok(raw) = fs::read_to_string(&member_toml) else {
continue;
};
let Ok(doc) = raw.parse::<DocumentMut>() else {
continue;
};
let has_own_version = doc
.get("package")
.and_then(|p| p.get("version"))
.is_some_and(|version| version.as_str().is_some());
if has_own_version {
return "independent";
}
}
"unified"
}
#[must_use]
pub fn parse_remote_owner_repo(url: &str) -> Option<(String, String)> {
let path = if url.contains("ssh://") {
url.splitn(4, '/').nth(3)?
} else if url.contains("://") {
url.splitn(4, '/').nth(3)?
} else {
url.split(':').nth(1)?
};
let path = path.trim_end_matches(".git");
let (owner, repo) = path.split_once('/')?;
Some((owner.to_owned(), repo.to_owned()))
}
#[cfg(test)]
mod tests {
use super::*;
fn write_member(root: &Path, dir: &str, manifest: &str) {
let d = root.join(dir);
fs::create_dir_all(d.join("src")).unwrap();
fs::write(d.join("Cargo.toml"), manifest).unwrap();
fs::write(d.join("src/lib.rs"), "").unwrap();
}
#[test]
fn detect_forge_from_github_url() {
assert_eq!(
forge_from_url("https://github.com/user/repo.git"),
Some("github")
);
assert_eq!(
forge_from_url("git@github.com:user/repo.git"),
Some("github")
);
}
#[test]
fn detect_forge_from_gitlab_url() {
assert_eq!(
forge_from_url("https://gitlab.com/user/repo.git"),
Some("gitlab")
);
assert_eq!(
forge_from_url("git@gitlab.com:user/repo.git"),
Some("gitlab")
);
}
#[test]
fn detect_forge_from_codeberg_url() {
assert_eq!(
forge_from_url("https://codeberg.org/user/repo.git"),
Some("forgejo")
);
assert_eq!(
forge_from_url("git@codeberg.org:user/repo.git"),
Some("forgejo")
);
}
#[test]
fn detect_forge_from_gitea_url() {
assert_eq!(
forge_from_url("https://gitea.com/user/repo.git"),
Some("gitea")
);
}
#[test]
fn detect_forge_unknown_url() {
assert_eq!(forge_from_url("https://example.com/user/repo.git"), None);
}
#[test]
fn detect_language_cargo() {
assert_eq!(language_from_files(&["Cargo.toml"]), Some("cargo"));
}
#[test]
fn detect_language_npm() {
assert_eq!(language_from_files(&["package.json"]), Some("npm"));
}
#[test]
fn detect_language_go() {
assert_eq!(language_from_files(&["go.mod"]), Some("go"));
}
#[test]
fn detect_language_cargo_wins_over_npm() {
assert_eq!(
language_from_files(&["Cargo.toml", "package.json"]),
Some("cargo")
);
}
#[test]
fn detect_language_unknown() {
assert_eq!(language_from_files(&["main.py"]), None);
}
#[test]
fn detects_unified_versioning() {
let dir = tempfile::tempdir().unwrap();
fs::write(
dir.path().join("Cargo.toml"),
r#"
[workspace]
members = ["lib"]
"#,
)
.unwrap();
fs::create_dir(dir.path().join("lib")).unwrap();
fs::write(
dir.path().join("lib/Cargo.toml"),
r#"
[package]
name = "mylib"
version.workspace = true
edition = "2024"
"#,
)
.unwrap();
assert_eq!(detect_versioning(&dir.path().join("Cargo.toml")), "unified");
}
#[test]
fn detects_independent_versioning() {
let dir = tempfile::tempdir().unwrap();
fs::write(
dir.path().join("Cargo.toml"),
r#"
[workspace]
members = ["lib"]
"#,
)
.unwrap();
write_member(
dir.path(),
"lib",
r#"
[package]
name = "mylib"
version = "0.3.0"
edition = "2024"
"#,
);
assert_eq!(
detect_versioning(&dir.path().join("Cargo.toml")),
"independent"
);
}
#[test]
fn mixed_members_detects_independent() {
let dir = tempfile::tempdir().unwrap();
fs::write(
dir.path().join("Cargo.toml"),
r#"
[workspace]
members = ["lib", "cli"]
resolver = "2"
[workspace.package]
version = "0.3.0"
"#,
)
.unwrap();
write_member(
dir.path(),
"lib",
r#"
[package]
name = "mylib"
version.workspace = true
edition = "2024"
"#,
);
write_member(
dir.path(),
"cli",
r#"
[package]
name = "mycli"
version = "0.7.0"
edition = "2024"
"#,
);
assert_eq!(
detect_versioning(&dir.path().join("Cargo.toml")),
"independent"
);
}
#[test]
fn parses_https_remote() {
let (owner, repo) =
parse_remote_owner_repo("https://codeberg.org/saylesss88/myrepo.git").unwrap();
assert_eq!(owner, "saylesss88");
assert_eq!(repo, "myrepo");
}
#[test]
fn parses_ssh_remote() {
let (owner, repo) =
parse_remote_owner_repo("git@codeberg.org:saylesss88/myrepo.git").unwrap();
assert_eq!(owner, "saylesss88");
assert_eq!(repo, "myrepo");
}
#[test]
fn parses_without_git_extension() {
let (owner, repo) =
parse_remote_owner_repo("https://codeberg.org/saylesss88/myrepo").unwrap();
assert_eq!(owner, "saylesss88");
assert_eq!(repo, "myrepo");
}
#[test]
fn returns_none_for_invalid_url() {
assert!(parse_remote_owner_repo("not-a-url").is_none());
}
#[test]
fn parses_ssh_url_scheme() {
let (owner, repo) =
parse_remote_owner_repo("ssh://git@codeberg.org/sayless88/test-jj-release.git")
.unwrap();
assert_eq!(owner, "sayless88");
assert_eq!(repo, "test-jj-release");
}
}